#include "wayland/gdkprivate-wayland.h"
#endif
-#ifdef GDK_WINDOWING_MIR
-#include "mir/gdkmir-private.h"
-#endif
-
/**
* SECTION:gdkdisplaymanager
* @Short_description: Maintains a list of all open GdkDisplays
#ifdef GDK_WINDOWING_WAYLAND
{ "wayland", _gdk_wayland_display_open },
#endif
-#ifdef GDK_WINDOWING_MIR
- { "mir", _gdk_mir_display_open },
-#endif
#ifdef GDK_WINDOWING_X11
{ "x11", gdk_x11_display_open },
#endif
gdkconfig_cdata.set('GDK_WINDOWING_WAYLAND', wayland_enabled)
gdkconfig_cdata.set('GDK_WINDOWING_WIN32', win32_enabled)
gdkconfig_cdata.set('GDK_WINDOWING_BROADWAY', broadway_enabled)
-gdkconfig_cdata.set('GDK_WINDOWING_MIR', mir_enabled)
gdkconfig_cdata.set('GDK_RENDERING_VULKAN', have_vulkan)
gdkconfig = configure_file(
gdk_backends = []
gdk_backends_gen_headers = [] # non-public generated headers
-foreach backend : ['broadway', 'mir', 'quartz', 'wayland', 'win32', 'x11']
+foreach backend : ['broadway', 'quartz', 'wayland', 'win32', 'x11']
if get_variable('@0@_enabled'.format(backend))
subdir(backend)
gdk_deps += get_variable('gdk_@0@_deps'.format(backend))
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "gdkmir-private.h"
-
-#include <mir_toolkit/events/window_placement.h>
-
-static void
-_gdk_mir_print_modifiers (unsigned int modifiers)
-{
- g_printerr (" Modifiers");
- if ((modifiers & mir_input_event_modifier_alt) != 0)
- g_printerr (" alt");
- if ((modifiers & mir_input_event_modifier_alt_left) != 0)
- g_printerr (" alt-left");
- if ((modifiers & mir_input_event_modifier_alt_right) != 0)
- g_printerr (" alt-right");
- if ((modifiers & mir_input_event_modifier_shift) != 0)
- g_printerr (" shift");
- if ((modifiers & mir_input_event_modifier_shift_left) != 0)
- g_printerr (" shift-left");
- if ((modifiers & mir_input_event_modifier_shift_right) != 0)
- g_printerr (" shift-right");
- if ((modifiers & mir_input_event_modifier_sym) != 0)
- g_printerr (" sym");
- if ((modifiers & mir_input_event_modifier_function) != 0)
- g_printerr (" function");
- if ((modifiers & mir_input_event_modifier_ctrl) != 0)
- g_printerr (" ctrl");
- if ((modifiers & mir_input_event_modifier_ctrl_left) != 0)
- g_printerr (" ctrl-left");
- if ((modifiers & mir_input_event_modifier_ctrl_right) != 0)
- g_printerr (" ctrl-right");
- if ((modifiers & mir_input_event_modifier_meta) != 0)
- g_printerr (" meta");
- if ((modifiers & mir_input_event_modifier_meta_left) != 0)
- g_printerr (" meta-left");
- if ((modifiers & mir_input_event_modifier_meta_right) != 0)
- g_printerr (" meta-right");
- if ((modifiers & mir_input_event_modifier_caps_lock) != 0)
- g_printerr (" caps-lock");
- if ((modifiers & mir_input_event_modifier_num_lock) != 0)
- g_printerr (" num-lock");
- if ((modifiers & mir_input_event_modifier_scroll_lock) != 0)
- g_printerr (" scroll-lock");
- g_printerr ("\n");
-}
-
-static void
-_gdk_mir_print_key_event (const MirInputEvent *event)
-{
- const MirKeyboardEvent *keyboard_event = mir_input_event_get_keyboard_event (event);
-
- if (!keyboard_event)
- return;
-
- g_printerr ("KEY\n");
- g_printerr (" Device %lld\n", (long long int) mir_input_event_get_device_id (event));
- g_printerr (" Action ");
- switch (mir_keyboard_event_action (keyboard_event))
- {
- case mir_keyboard_action_down:
- g_printerr ("down");
- break;
- case mir_keyboard_action_up:
- g_printerr ("up");
- break;
- case mir_keyboard_action_repeat:
- g_printerr ("repeat");
- break;
- default:
- g_printerr ("%u", mir_keyboard_event_action (keyboard_event));
- break;
- }
- g_printerr ("\n");
- _gdk_mir_print_modifiers (mir_keyboard_event_modifiers (keyboard_event));
- g_printerr (" Key Code %i\n", mir_keyboard_event_key_code (keyboard_event));
- g_printerr (" Scan Code %i\n", mir_keyboard_event_scan_code (keyboard_event));
- g_printerr (" Event Time %lli\n", (long long int) mir_input_event_get_event_time (event));
-}
-
-static void
-_gdk_mir_print_touch_event (const MirInputEvent *event)
-{
- const MirTouchEvent *touch_event = mir_input_event_get_touch_event (event);
- guint i;
- guint n;
-
- if (!touch_event)
- return;
-
- g_printerr ("TOUCH\n");
- g_printerr (" Device %lld\n", (long long int) mir_input_event_get_device_id (event));
- g_printerr (" Event Time %lld\n", (long long int) mir_input_event_get_event_time (event));
- _gdk_mir_print_modifiers (mir_touch_event_modifiers (touch_event));
- n = mir_touch_event_point_count (touch_event);
-
- for (i = 0; i < n; i++)
- {
- g_printerr (" [%u] (%u/%u) ", mir_touch_event_id (touch_event, i), i + 1, n);
- switch (mir_touch_event_action (touch_event, i))
- {
- case mir_touch_action_down:
- g_printerr ("Down");
- break;
- case mir_touch_action_up:
- g_printerr ("Up");
- break;
- case mir_touch_action_change:
- g_printerr ("Change");
- break;
- default:
- g_printerr ("%u", mir_touch_event_action (touch_event, i));
- break;
- }
- switch (mir_touch_event_tooltype (touch_event, i))
- {
- default:
- case mir_touch_tooltype_unknown:
- g_printerr (" ? ");
- break;
- case mir_touch_tooltype_finger:
- g_printerr (" finger ");
- break;
- case mir_touch_tooltype_stylus:
- g_printerr (" stylus ");
- break;
- }
- g_printerr ("\n x: %f y: %f P: %f A: %f B: %f d: %f\n",
- mir_touch_event_axis_value (touch_event, i, mir_touch_axis_x),
- mir_touch_event_axis_value (touch_event, i, mir_touch_axis_y),
- mir_touch_event_axis_value (touch_event, i, mir_touch_axis_pressure),
- mir_touch_event_axis_value (touch_event, i, mir_touch_axis_touch_major),
- mir_touch_event_axis_value (touch_event, i, mir_touch_axis_touch_minor),
- mir_touch_event_axis_value (touch_event, i, mir_touch_axis_size));
- }
-}
-
-static void
-_gdk_mir_print_motion_event (const MirInputEvent *event)
-{
- const MirPointerEvent *pointer_event = mir_input_event_get_pointer_event (event);
-
- if (!pointer_event)
- return;
-
- g_printerr ("MOTION\n");
- g_printerr (" Device %lld\n", (long long int) mir_input_event_get_device_id (event));
- g_printerr (" Action ");
- switch (mir_pointer_event_action (pointer_event))
- {
- case mir_pointer_action_button_down:
- g_printerr ("down");
- break;
- case mir_pointer_action_button_up:
- g_printerr ("up");
- break;
- case mir_pointer_action_enter:
- g_printerr ("enter");
- break;
- case mir_pointer_action_leave:
- g_printerr ("leave");
- break;
- case mir_pointer_action_motion:
- g_printerr ("motion");
- break;
- default:
- g_printerr ("%u", mir_pointer_event_action (pointer_event));
- }
- g_printerr ("\n");
- _gdk_mir_print_modifiers (mir_pointer_event_modifiers (pointer_event));
- g_printerr (" Button State");
- if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_primary))
- g_printerr (" primary");
- if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_secondary))
- g_printerr (" secondary");
- if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_tertiary))
- g_printerr (" tertiary");
- if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_back))
- g_printerr (" back");
- if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_forward))
- g_printerr (" forward");
- g_printerr ("\n");
- g_printerr (" Offset (%f, %f)\n", mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_x),
- mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_y));
- g_printerr (" Scroll (%f, %f)\n", mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_hscroll),
- mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_vscroll));
- g_printerr (" Event Time %lli\n", (long long int) mir_input_event_get_event_time (event));
-}
-
-static void
-_gdk_mir_print_input_event (const MirInputEvent *event)
-{
- g_printerr ("INPUT\n");
-}
-
-static void
-_gdk_mir_print_window_event (const MirWindowEvent *event)
-{
- g_printerr ("WINDOW\n");
- g_printerr (" Attribute ");
- switch (mir_window_event_get_attribute (event))
- {
- case mir_window_attrib_type:
- g_printerr ("type");
- break;
- case mir_window_attrib_state:
- g_printerr ("state");
- break;
- case mir_window_attrib_swapinterval:
- g_printerr ("swapinterval");
- break;
- case mir_window_attrib_focus:
- g_printerr ("focus");
- break;
- case mir_window_attrib_dpi:
- g_printerr ("dpi");
- break;
- case mir_window_attrib_visibility:
- g_printerr ("visibility");
- break;
- case mir_window_attrib_preferred_orientation:
- g_printerr ("preferred_orientation");
- break;
- default:
- g_printerr ("%u", mir_window_event_get_attribute (event));
- break;
- }
- g_printerr ("\n");
- g_printerr (" Value %i\n", mir_window_event_get_attribute_value (event));
-}
-
-static void
-_gdk_mir_print_resize_event (const MirResizeEvent *event)
-{
- g_printerr ("RESIZE\n");
- g_printerr (" Size (%i, %i)\n", mir_resize_event_get_width (event), mir_resize_event_get_height (event));
-}
-
-static void
-_gdk_mir_print_prompt_session_state_change_event (const MirPromptSessionEvent *event)
-{
- g_printerr ("PROMPT_SESSION_STATE_CHANGE\n");
- g_printerr (" State ");
-
- switch (mir_prompt_session_event_get_state (event))
- {
- case mir_prompt_session_state_stopped:
- g_printerr ("stopped");
- break;
- case mir_prompt_session_state_started:
- g_printerr ("started");
- break;
- case mir_prompt_session_state_suspended:
- g_printerr ("suspended");
- break;
- default:
- g_printerr ("%u", mir_prompt_session_event_get_state (event));
- break;
- }
-
- g_printerr ("\n");
-}
-
-static void
-_gdk_mir_print_orientation_event (const MirOrientationEvent *event)
-{
- g_printerr ("ORIENTATION\n");
- g_printerr (" Direction ");
-
- switch (mir_orientation_event_get_direction (event))
- {
- case mir_orientation_normal:
- g_printerr ("normal");
- break;
- case mir_orientation_left:
- g_printerr ("left");
- break;
- case mir_orientation_inverted:
- g_printerr ("inverted");
- break;
- case mir_orientation_right:
- g_printerr ("right");
- break;
- default:
- g_printerr ("%u", mir_orientation_event_get_direction (event));
- break;
- }
-
- g_printerr ("\n");
-}
-
-static void
-_gdk_mir_print_close_event (void)
-{
- g_printerr ("CLOSED\n");
-}
-
-static void
-_gdk_mir_print_keymap_event (const MirKeymapEvent *event)
-{
- g_printerr ("KEYMAP\n");
-}
-
-static void
-_gdk_mir_print_window_output_event (const MirWindowOutputEvent *event)
-{
- g_printerr ("WINDOW_OUTPUT\n");
- g_printerr (" DPI %d\n", mir_window_output_event_get_dpi (event));
- g_printerr (" Form Factor ");
-
- switch (mir_window_output_event_get_form_factor (event))
- {
- case mir_form_factor_unknown:
- g_printerr ("unknown");
- break;
- case mir_form_factor_phone:
- g_printerr ("phone");
- break;
- case mir_form_factor_tablet:
- g_printerr ("tablet");
- break;
- case mir_form_factor_monitor:
- g_printerr ("monitor");
- break;
- case mir_form_factor_tv:
- g_printerr ("tv");
- break;
- case mir_form_factor_projector:
- g_printerr ("projector");
- break;
- default:
- g_printerr ("%u", mir_window_output_event_get_form_factor (event));
- break;
- }
-
- g_printerr ("\n");
- g_printerr (" Scale %f\n", mir_window_output_event_get_scale (event));
- g_printerr (" Refresh Rate %lf\n", mir_window_output_event_get_refresh_rate (event));
- g_printerr (" Output ID %u\n", mir_window_output_event_get_output_id (event));
-}
-
-static void
-_gdk_mir_print_input_device_state_event (const MirInputDeviceStateEvent *event)
-{
- MirPointerButtons buttons;
- MirInputEventModifiers modifiers;
- gint i;
- gint j;
-
- g_printerr ("INPUT_DEVICE_STATE\n");
- g_printerr (" Pointer Buttons\n");
- buttons = mir_input_device_state_event_pointer_buttons (event);
-
- if (buttons == 0)
- g_printerr (" none\n");
- else
- {
- if (buttons & mir_pointer_button_primary)
- g_printerr (" primary\n");
- if (buttons & mir_pointer_button_secondary)
- g_printerr (" secondary\n");
- if (buttons & mir_pointer_button_tertiary)
- g_printerr (" tertiary\n");
- if (buttons & mir_pointer_button_back)
- g_printerr (" back\n");
- if (buttons & mir_pointer_button_forward)
- g_printerr (" forward\n");
- if (buttons & mir_pointer_button_side)
- g_printerr (" side\n");
- if (buttons & mir_pointer_button_extra)
- g_printerr (" extra\n");
- if (buttons & mir_pointer_button_task)
- g_printerr (" task\n");
- }
-
- g_printerr (" Pointer Axis\n");
- g_printerr (" X %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_x));
- g_printerr (" Y %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_y));
- g_printerr (" V Scroll %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_vscroll));
- g_printerr (" H Scroll %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_hscroll));
- g_printerr (" Relative X %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_relative_x));
- g_printerr (" Relative Y %f\n", mir_input_device_state_event_pointer_axis (event, mir_pointer_axis_relative_y));
- g_printerr (" Time %ld\n", mir_input_device_state_event_time (event));
- g_printerr (" Event Modifiers\n");
- modifiers = mir_input_device_state_event_modifiers (event);
-
- if (modifiers & mir_input_event_modifier_none)
- g_printerr (" none\n");
- if (modifiers & mir_input_event_modifier_alt)
- g_printerr (" alt\n");
- if (modifiers & mir_input_event_modifier_alt_left)
- g_printerr (" alt_left\n");
- if (modifiers & mir_input_event_modifier_alt_right)
- g_printerr (" alt_right\n");
- if (modifiers & mir_input_event_modifier_shift)
- g_printerr (" shift\n");
- if (modifiers & mir_input_event_modifier_shift_left)
- g_printerr (" shift_left\n");
- if (modifiers & mir_input_event_modifier_shift_right)
- g_printerr (" shift_right\n");
- if (modifiers & mir_input_event_modifier_sym)
- g_printerr (" sym\n");
- if (modifiers & mir_input_event_modifier_function)
- g_printerr (" function\n");
- if (modifiers & mir_input_event_modifier_ctrl)
- g_printerr (" ctrl\n");
- if (modifiers & mir_input_event_modifier_ctrl_left)
- g_printerr (" ctrl_left\n");
- if (modifiers & mir_input_event_modifier_ctrl_right)
- g_printerr (" ctrl_right\n");
- if (modifiers & mir_input_event_modifier_meta)
- g_printerr (" meta\n");
- if (modifiers & mir_input_event_modifier_meta_left)
- g_printerr (" meta_left\n");
- if (modifiers & mir_input_event_modifier_meta_right)
- g_printerr (" meta_right\n");
- if (modifiers & mir_input_event_modifier_caps_lock)
- g_printerr (" caps_lock\n");
- if (modifiers & mir_input_event_modifier_num_lock)
- g_printerr (" num_lock\n");
- if (modifiers & mir_input_event_modifier_scroll_lock)
- g_printerr (" scroll_lock\n");
-
- for (i = 0; i < mir_input_device_state_event_device_count (event); i++)
- {
- g_printerr (" Device %ld\n", mir_input_device_state_event_device_id (event, i));
-
- for (j = 0; j < mir_input_device_state_event_device_pressed_keys_count (event, i); j++)
- g_printerr (" Pressed %u\n", mir_input_device_state_event_device_pressed_keys_for_index (event, i, j));
-
- g_printerr (" Pointer Buttons\n");
- buttons = mir_input_device_state_event_device_pointer_buttons (event, i);
-
- if (buttons == 0)
- g_printerr (" none\n");
- else
- {
- if (buttons & mir_pointer_button_primary)
- g_printerr (" primary\n");
- if (buttons & mir_pointer_button_secondary)
- g_printerr (" secondary\n");
- if (buttons & mir_pointer_button_tertiary)
- g_printerr (" tertiary\n");
- if (buttons & mir_pointer_button_back)
- g_printerr (" back\n");
- if (buttons & mir_pointer_button_forward)
- g_printerr (" forward\n");
- if (buttons & mir_pointer_button_side)
- g_printerr (" side\n");
- if (buttons & mir_pointer_button_extra)
- g_printerr (" extra\n");
- if (buttons & mir_pointer_button_task)
- g_printerr (" task\n");
- }
- }
-}
-
-static void
-_gdk_mir_print_window_placement_event (const MirWindowPlacementEvent *event)
-{
- MirRectangle rect = mir_window_placement_get_relative_position (event);
-
- g_printerr ("WINDOW_PLACEMENT\n");
- g_printerr (" X %d\n", rect.left);
- g_printerr (" Y %d\n", rect.top);
- g_printerr (" Width %u\n", rect.width);
- g_printerr (" Height %u\n", rect.height);
-}
-
-void
-_gdk_mir_print_event (const MirEvent *event)
-{
- const MirInputEvent *input_event;
-
- switch (mir_event_get_type (event))
- {
- case mir_event_type_input:
- input_event = mir_event_get_input_event (event);
-
- switch (mir_input_event_get_type (input_event))
- {
- case mir_input_event_type_key:
- _gdk_mir_print_key_event (mir_event_get_input_event (event));
- break;
- case mir_input_event_type_touch:
- _gdk_mir_print_touch_event (mir_event_get_input_event (event));
- break;
- case mir_input_event_type_pointer:
- _gdk_mir_print_motion_event (mir_event_get_input_event (event));
- break;
- default:
- _gdk_mir_print_input_event (mir_event_get_input_event (event));
- break;
- }
- break;
- case mir_event_type_key:
- _gdk_mir_print_key_event (mir_event_get_input_event (event));
- break;
- case mir_event_type_motion:
- _gdk_mir_print_motion_event (mir_event_get_input_event (event));
- break;
- case mir_event_type_window:
- _gdk_mir_print_window_event (mir_event_get_window_event (event));
- break;
- case mir_event_type_resize:
- _gdk_mir_print_resize_event (mir_event_get_resize_event (event));
- break;
- case mir_event_type_prompt_session_state_change:
- _gdk_mir_print_prompt_session_state_change_event (mir_event_get_prompt_session_event (event));
- break;
- case mir_event_type_orientation:
- _gdk_mir_print_orientation_event (mir_event_get_orientation_event (event));
- break;
- case mir_event_type_close_window:
- _gdk_mir_print_close_event ();
- break;
- case mir_event_type_keymap:
- _gdk_mir_print_keymap_event (mir_event_get_keymap_event (event));
- break;
- case mir_event_type_window_output:
- _gdk_mir_print_window_output_event (mir_event_get_window_output_event (event));
- break;
- case mir_event_type_input_device_state:
- _gdk_mir_print_input_device_state_event (mir_event_get_input_device_state_event (event));
- break;
- case mir_event_type_window_placement:
- _gdk_mir_print_window_placement_event (mir_event_get_window_placement_event (event));
- break;
- default:
- g_printerr ("EVENT %u\n", mir_event_get_type (event));
- break;
- }
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __GDK_PRIVATE_MIR_H__
-#define __GDK_PRIVATE_MIR_H__
-
-#include <epoxy/egl.h>
-
-#include "gdkmir.h"
-#include "gdkdisplay.h"
-#include "gdkscreen.h"
-#include "gdkdevicemanager.h"
-#include "gdkglcontextprivate.h"
-#include "gdkkeys.h"
-#include "gdkwindowimpl.h"
-
-typedef struct _GdkMirWindowImpl GdkMirWindowImpl;
-typedef struct _GdkMirWindowReference GdkMirWindowReference;
-typedef struct _GdkMirEventSource GdkMirEventSource;
-
-#define GDK_TYPE_MIR_WINDOW_IMPL (gdk_mir_window_impl_get_type ())
-#define GDK_MIR_WINDOW_IMPL(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_WINDOW_IMPL, GdkMirWindowImpl))
-#define GDK_IS_WINDOW_IMPL_MIR(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_WINDOW_IMPL))
-
-GType gdk_mir_window_impl_get_type (void);
-
-
-struct _GdkMirGLContext
-{
- GdkGLContext parent_instance;
-
- EGLContext egl_context;
- EGLConfig egl_config;
- gboolean is_attached;
-};
-
-struct _GdkMirGLContextClass
-{
- GdkGLContextClass parent_class;
-};
-
-typedef struct _GdkMirGLContext GdkMirGLContext;
-typedef struct _GdkMirGLContextClass GdkMirGLContextClass;
-
-#define GDK_MIR_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_MIR_GL_CONTEXT, GdkMirGLContext))
-
-
-GdkDisplay *_gdk_mir_display_open (const gchar *display_name);
-
-GdkScreen *_gdk_mir_screen_new (GdkDisplay *display);
-
-GdkDeviceManager *_gdk_mir_device_manager_new (GdkDisplay *display);
-
-GdkDevice *_gdk_mir_device_manager_get_keyboard (GdkDeviceManager *device_manager);
-
-GdkKeymap *_gdk_mir_keymap_new (void);
-
-gboolean _gdk_mir_keymap_key_is_modifier (GdkKeymap *keymap, guint keycode);
-
-GdkDevice *_gdk_mir_keyboard_new (GdkDeviceManager *device_manager, const gchar *name);
-
-GdkDevice *_gdk_mir_pointer_new (GdkDeviceManager *device_manager, const gchar *name);
-
-void _gdk_mir_pointer_set_location (GdkDevice *pointer, gdouble x, gdouble y, GdkWindow *window, GdkModifierType mask);
-
-const gchar *_gdk_mir_cursor_get_name (GdkCursor *cursor);
-
-MirWindow *_gdk_mir_window_get_mir_window (GdkWindow *window);
-
-GdkWindowImpl *_gdk_mir_window_impl_new (GdkDisplay *display, GdkWindow *window);
-
-void _gdk_mir_window_impl_set_window_state (GdkMirWindowImpl *impl, MirWindowState state);
-
-void _gdk_mir_window_impl_set_window_type (GdkMirWindowImpl *impl, MirWindowType type);
-
-void _gdk_mir_window_set_scale (GdkWindow *window, gdouble scale);
-
-void _gdk_mir_window_set_final_rect (GdkWindow *window, MirRectangle rect);
-
-void _gdk_mir_window_impl_set_cursor_state (GdkMirWindowImpl *impl, gdouble x, gdouble y, gboolean cursor_inside, guint button_state);
-
-void _gdk_mir_window_impl_get_cursor_state (GdkMirWindowImpl *impl, gdouble *x, gdouble *y, gboolean *cursor_inside, guint *button_state);
-
-GdkMirEventSource *_gdk_mir_display_get_event_source (GdkDisplay *display);
-
-GdkMirEventSource *_gdk_mir_event_source_new (GdkDisplay *display);
-
-GdkMirWindowReference *_gdk_mir_event_source_get_window_reference (GdkWindow *window);
-
-void _gdk_mir_window_reference_unref (GdkMirWindowReference *ref);
-
-void _gdk_mir_event_source_queue (GdkMirWindowReference *window_ref, const MirEvent *event);
-
-MirPixelFormat _gdk_mir_display_get_pixel_format (GdkDisplay *display, MirBufferUsage usage);
-
-void _gdk_mir_display_focus_window (GdkDisplay *display, GdkWindow *window);
-
-void _gdk_mir_display_unfocus_window (GdkDisplay *display, GdkWindow *window);
-
-void _gdk_mir_display_create_paste (GdkDisplay *display,
- const gchar * const *paste_formats,
- gconstpointer paste_data,
- gsize paste_size);
-
-gboolean _gdk_mir_display_init_egl_display (GdkDisplay *display);
-
-EGLDisplay _gdk_mir_display_get_egl_display (GdkDisplay *display);
-
-gboolean _gdk_mir_display_have_egl_khr_create_context (GdkDisplay *display);
-
-gboolean _gdk_mir_display_have_egl_buffer_age (GdkDisplay *display);
-
-gboolean _gdk_mir_display_have_egl_swap_buffers_with_damage (GdkDisplay *display);
-
-gboolean _gdk_mir_display_have_egl_surfaceless_context (GdkDisplay *display);
-
-EGLSurface _gdk_mir_window_get_egl_surface (GdkWindow *window, EGLConfig config);
-
-EGLSurface _gdk_mir_window_get_dummy_egl_surface (GdkWindow *window, EGLConfig config);
-
-void _gdk_mir_print_event (const MirEvent *event);
-
-gboolean gdk_mir_screen_get_setting (GdkScreen *screen,
- const gchar *name,
- GValue *value);
-
-
-
-#endif /* __GDK_PRIVATE_MIR_H__ */
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __GDK_MIR_H__
-#define __GDK_MIR_H__
-
-#include <gdk/gdk.h>
-#include <mir_toolkit/mir_client_library.h>
-
-G_BEGIN_DECLS
-
-#define GDK_TYPE_MIR_DISPLAY (gdk_mir_display_get_type ())
-#define GDK_IS_MIR_DISPLAY(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_DISPLAY))
-
-#define GDK_TYPE_MIR_GL_CONTEXT (gdk_mir_gl_context_get_type ())
-#define GDK_MIR_IS_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_MIR_GL_CONTEXT))
-
-#define GDK_TYPE_MIR_WINDOW (gdk_mir_window_get_type ())
-#define GDK_IS_MIR_WINDOW(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_WINDOW))
-
-GDK_AVAILABLE_IN_3_16
-GType gdk_mir_display_get_type (void);
-
-GDK_AVAILABLE_IN_3_16
-MirConnection *gdk_mir_display_get_mir_connection (GdkDisplay *display);
-
-GDK_AVAILABLE_IN_3_16
-GType gdk_mir_window_get_type (void);
-
-GDK_DEPRECATED_IN_3_22
-MirSurface *gdk_mir_window_get_mir_surface (GdkWindow *window);
-
-GDK_AVAILABLE_IN_3_16
-GType gdk_mir_gl_context_get_type (void) G_GNUC_CONST;
-
-G_END_DECLS
-
-#endif /* __GDK_MIR_H__ */
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include "gdkcursorprivate.h"
-
-#include "gdkmir.h"
-#include "gdkmir-private.h"
-
-typedef struct GdkMirCursor GdkMirCursor;
-typedef struct GdkMirCursorClass GdkMirCursorClass;
-
-#define GDK_TYPE_MIR_CURSOR (gdk_mir_cursor_get_type ())
-#define GDK_MIR_CURSOR(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_CURSOR, GdkMirCursor))
-#define GDK_MIR_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_CURSOR, GdkMirCursorClass))
-#define GDK_IS_MIR_CURSOR(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_CURSOR))
-#define GDK_IS_MIR_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_CURSOR))
-#define GDK_MIR_CURSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_CURSOR, GdkMirCursorClass))
-
-struct GdkMirCursor
-{
- GdkCursor parent_instance;
-
- gchar *name;
-};
-
-struct GdkMirCursorClass
-{
- GdkCursorClass parent_class;
-};
-
-G_DEFINE_TYPE (GdkMirCursor, gdk_mir_cursor, GDK_TYPE_CURSOR)
-
-static const gchar *
-get_cursor_name_for_cursor_type (GdkCursorType cursor_type)
-{
- switch (cursor_type)
- {
- case GDK_BLANK_CURSOR:
- return mir_disabled_cursor_name;
- case GDK_X_CURSOR:
- case GDK_ARROW:
- case GDK_CENTER_PTR:
- case GDK_DRAFT_LARGE:
- case GDK_DRAFT_SMALL:
- case GDK_LEFT_PTR:
- case GDK_RIGHT_PTR:
- case GDK_TOP_LEFT_ARROW:
- return mir_arrow_cursor_name;
- case GDK_CLOCK:
- case GDK_WATCH:
- return mir_busy_cursor_name;
- case GDK_XTERM:
- return mir_caret_cursor_name;
- case GDK_HAND1:
- case GDK_HAND2:
- return mir_pointing_hand_cursor_name;
- return mir_open_hand_cursor_name;
- case GDK_FLEUR:
- return mir_closed_hand_cursor_name;
- case GDK_LEFT_SIDE:
- case GDK_LEFT_TEE:
- case GDK_RIGHT_SIDE:
- case GDK_RIGHT_TEE:
- case GDK_SB_LEFT_ARROW:
- case GDK_SB_RIGHT_ARROW:
- return mir_horizontal_resize_cursor_name;
- case GDK_BASED_ARROW_DOWN:
- case GDK_BASED_ARROW_UP:
- case GDK_BOTTOM_SIDE:
- case GDK_BOTTOM_TEE:
- case GDK_DOUBLE_ARROW:
- case GDK_SB_DOWN_ARROW:
- case GDK_SB_UP_ARROW:
- case GDK_TOP_SIDE:
- case GDK_TOP_TEE:
- return mir_vertical_resize_cursor_name;
- case GDK_BOTTOM_LEFT_CORNER:
- case GDK_LL_ANGLE:
- case GDK_TOP_RIGHT_CORNER:
- case GDK_UR_ANGLE:
- return mir_diagonal_resize_bottom_to_top_cursor_name;
- case GDK_BOTTOM_RIGHT_CORNER:
- case GDK_LR_ANGLE:
- case GDK_SIZING:
- case GDK_TOP_LEFT_CORNER:
- case GDK_UL_ANGLE:
- return mir_diagonal_resize_top_to_bottom_cursor_name;
- return mir_omnidirectional_resize_cursor_name;
- case GDK_SB_V_DOUBLE_ARROW:
- return mir_vsplit_resize_cursor_name;
- case GDK_SB_H_DOUBLE_ARROW:
- return mir_hsplit_resize_cursor_name;
- default:
- return mir_default_cursor_name;
- }
-}
-
-
-GdkCursor *
-_gdk_mir_cursor_new_for_name (GdkDisplay *display, const gchar *name)
-{
- GdkMirCursor *cursor;
-
- cursor = g_object_new (GDK_TYPE_MIR_CURSOR, "display", display, "cursor-type", GDK_CURSOR_IS_PIXMAP, NULL);
- cursor->name = g_strdup (name);
-
- return GDK_CURSOR (cursor);
-}
-
-GdkCursor *
-_gdk_mir_cursor_new_for_type (GdkDisplay *display, GdkCursorType type)
-{
- GdkMirCursor *cursor;
-
- cursor = g_object_new (GDK_TYPE_MIR_CURSOR, "display", display, "cursor-type", type, NULL);
- cursor->name = g_strdup (get_cursor_name_for_cursor_type (type));
-
- return GDK_CURSOR (cursor);
-}
-
-const gchar *
-_gdk_mir_cursor_get_name (GdkCursor *cursor)
-{
- GdkMirCursor *mir_cursor = GDK_MIR_CURSOR (cursor);
-
- return mir_cursor->name;
-}
-
-static void
-gdk_mir_cursor_init (GdkMirCursor *cursor)
-{
-}
-
-static void
-gdk_mir_cursor_finalize (GObject *object)
-{
- GdkMirCursor *mir_cursor = GDK_MIR_CURSOR (object);
-
- g_free (mir_cursor->name);
-
- G_OBJECT_CLASS (gdk_mir_cursor_parent_class)->finalize (object);
-}
-
-static void
-gdk_mir_cursor_class_init (GdkMirCursorClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
- object_class->finalize = gdk_mir_cursor_finalize;
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include "gdkdevicemanagerprivate.h"
-#include "gdkdisplayprivate.h"
-#include "gdkdeviceprivate.h"
-#include "gdkseatdefaultprivate.h"
-
-#include "gdkmir.h"
-#include "gdkmir-private.h"
-
-typedef struct GdkMirDeviceManager GdkMirDeviceManager;
-typedef struct GdkMirDeviceManagerClass GdkMirDeviceManagerClass;
-
-#define GDK_TYPE_MIR_DEVICE_MANAGER (gdk_mir_device_manager_get_type ())
-#define GDK_MIR_DEVICE_MANAGER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_DEVICE_MANAGER, GdkMirDeviceManager))
-#define GDK_MIR_DEVICE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_DEVICE_MANAGER, GdkMirDeviceManagerClass))
-#define GDK_IS_MIR_DEVICE_MANAGER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_DEVICE_MANAGER))
-#define GDK_IS_MIR_DEVICE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_DEVICE_MANAGER))
-#define GDK_MIR_DEVICE_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_DEVICE_MANAGER, GdkMirDeviceManagerClass))
-
-struct GdkMirDeviceManager
-{
- GdkDeviceManager parent_instance;
-
- GdkDevice *pointer;
- GdkDevice *keyboard;
-};
-
-struct GdkMirDeviceManagerClass
-{
- GdkDeviceManagerClass parent_class;
-};
-
-G_DEFINE_TYPE (GdkMirDeviceManager, gdk_mir_device_manager, GDK_TYPE_DEVICE_MANAGER)
-
-GdkDeviceManager *
-_gdk_mir_device_manager_new (GdkDisplay *display)
-{
- return g_object_new (GDK_TYPE_MIR_DEVICE_MANAGER, "display", display, NULL);
-}
-
-static GList *
-gdk_mir_device_manager_list_devices (GdkDeviceManager *device_manager,
- GdkDeviceType type)
-{
- GdkMirDeviceManager *dm = GDK_MIR_DEVICE_MANAGER (device_manager);
-
- if (type == GDK_DEVICE_TYPE_MASTER)
- {
- GList *devices;
-
- devices = g_list_append (NULL, dm->keyboard);
- devices = g_list_append (devices, dm->pointer);
-
- return devices;
- }
-
- return NULL;
-}
-
-static GdkDevice *
-gdk_mir_device_manager_get_client_pointer (GdkDeviceManager *device_manager)
-{
- return GDK_MIR_DEVICE_MANAGER (device_manager)->pointer;
-}
-
-GdkDevice *
-_gdk_mir_device_manager_get_keyboard (GdkDeviceManager *device_manager)
-{
- return GDK_MIR_DEVICE_MANAGER (device_manager)->keyboard;
-}
-
-static void
-gdk_mir_device_manager_init (GdkMirDeviceManager *device_manager)
-{
-}
-
-static void
-gdk_mir_device_manager_constructed (GObject *object)
-{
- GdkMirDeviceManager *device_manager = GDK_MIR_DEVICE_MANAGER (object);
- GdkDisplay *display;
- GdkSeat *seat;
-
- device_manager->keyboard = _gdk_mir_keyboard_new (GDK_DEVICE_MANAGER (device_manager), "Mir Keyboard");
- device_manager->pointer = _gdk_mir_pointer_new (GDK_DEVICE_MANAGER (device_manager), "Mir Pointer");
- _gdk_device_set_associated_device (device_manager->keyboard, device_manager->pointer);
- _gdk_device_set_associated_device (device_manager->pointer, device_manager->keyboard);
-
- display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (device_manager));
-
- seat = gdk_seat_default_new_for_master_pair (device_manager->pointer, device_manager->keyboard);
- gdk_display_add_seat (display, seat);
- g_object_unref (seat);
-
- G_OBJECT_CLASS (gdk_mir_device_manager_parent_class)->constructed (object);
-}
-
-static void
-gdk_mir_device_manager_class_init (GdkMirDeviceManagerClass *klass)
-{
- GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
- device_manager_class->list_devices = gdk_mir_device_manager_list_devices;
- device_manager_class->get_client_pointer = gdk_mir_device_manager_get_client_pointer;
- object_class->constructed = gdk_mir_device_manager_constructed;
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include "gdkdisplayprivate.h"
-#include "gdkmonitorprivate.h"
-#include "gdkinternals.h"
-
-#include "gdkmir.h"
-#include "gdkmir-private.h"
-
-#include <string.h>
-
-#include <com/ubuntu/content/glib/content-hub-glib.h>
-
-#define GDK_TYPE_DISPLAY_MIR (gdk_mir_display_get_type ())
-#define GDK_MIR_DISPLAY(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MIR, GdkMirDisplay))
-#define GDK_MIR_DISPLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY_MIR, GdkMirDisplayClass))
-#define GDK_IS_MIR_DISPLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_DISPLAY))
-#define GDK_MIR_DISPLAY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_DISPLAY, GdkMirDisplayImplClass))
-
-typedef struct GdkMirDisplay
-{
- GdkDisplay parent_instance;
-
- /* Connection to Mir server */
- MirConnection *connection;
-
- const MirDisplayConfig *config;
- GList *monitors;
-
- /* Event source */
- GdkMirEventSource *event_source;
-
- /* Serial number? */
- gulong serial;
-
- /* Screen information */
- GdkScreen *screen;
-
- GdkKeymap *keymap;
-
- GdkWindow *focused_window;
-
- MirPixelFormat sw_pixel_format;
- MirPixelFormat hw_pixel_format;
-
- EGLDisplay egl_display;
- guint have_egl_khr_create_context : 1;
- guint have_egl_buffer_age : 1;
- guint have_egl_swap_buffers_with_damage : 1;
- guint have_egl_surfaceless_context : 1;
-
- ContentHubService *content_service;
- ContentHubHandler *content_handler;
- GVariant *paste_data;
-} GdkMirDisplay;
-
-typedef struct GdkMirDisplayClass
-{
- GdkDisplayClass parent_class;
-} GdkMirDisplayClass;
-
-static void get_pixel_formats (MirConnection *, MirPixelFormat *sw, MirPixelFormat *hw);
-
-/**
- * SECTION:mir_interaction
- * @Short_description: Mir backend-specific functions
- * @Title: Mir Interaction
- *
- * The functions in this section are specific to the GDK Mir backend.
- * To use them, you need to include the <literal><gdk/gdkmir.h></literal>
- * header and use the Mir-specific pkg-config files to build your
- * application (either <literal>gdk-mir-3.0</literal> or
- * <literal>gtk+-mir-3.0</literal>).
- *
- * To make your code compile with other GDK backends, guard backend-specific
- * calls by an ifdef as follows. Since GDK may be built with multiple
- * backends, you should also check for the backend that is in use (e.g. by
- * using the GDK_IS_MIR_DISPLAY() macro).
- * |[
- * #ifdef GDK_WINDOWING_MIR
- * if (GDK_IS_MIR_DISPLAY (display))
- * {
- * /* make Mir-specific calls here */
- * }
- * else
- * #endif
- * #ifdef GDK_WINDOWING_X11
- * if (GDK_IS_X11_DISPLAY (display))
- * {
- * /* make X11-specific calls here */
- * }
- * else
- * #endif
- * g_error ("Unsupported GDK backend");
- * ]|
- */
-
-G_DEFINE_TYPE (GdkMirDisplay, gdk_mir_display, GDK_TYPE_DISPLAY)
-
-static void
-config_changed_cb (MirConnection *connection,
- void *context)
-{
- GdkMirDisplay *display = context;
- GdkMonitor *monitor;
- const MirOutput *output;
- const MirOutputMode *mode;
- gint i;
-
- g_list_free_full (display->monitors, g_object_unref);
- g_clear_pointer (&display->config, mir_display_config_release);
-
- display->config = mir_connection_create_display_configuration (display->connection);
- display->monitors = NULL;
-
- for (i = mir_display_config_get_num_outputs (display->config) - 1; i >= 0; i--)
- {
- output = mir_display_config_get_output (display->config, i);
-
- if (!mir_output_is_enabled (output))
- continue;
-
- mode = mir_output_get_current_mode (output);
- monitor = gdk_monitor_new (GDK_DISPLAY (display));
-
- gdk_monitor_set_position (monitor,
- mir_output_get_position_x (output),
- mir_output_get_position_y (output));
-
- gdk_monitor_set_size (monitor,
- mir_output_mode_get_width (mode),
- mir_output_mode_get_height (mode));
-
- gdk_monitor_set_physical_size (monitor,
- mir_output_get_physical_width_mm (output),
- mir_output_get_physical_height_mm (output));
-
- gdk_monitor_set_scale_factor (monitor,
- (gint) mir_output_get_scale_factor (output));
-
- gdk_monitor_set_refresh_rate (monitor,
- (gint) mir_output_mode_get_refresh_rate (mode));
-
- display->monitors = g_list_prepend (display->monitors, monitor);
- }
-}
-
-static void
-pasteboard_changed_cb (GdkMirDisplay *display,
- gpointer user_data)
-{
- g_clear_pointer (&display->paste_data, g_variant_unref);
-}
-
-GdkDisplay *
-_gdk_mir_display_open (const gchar *display_name)
-{
- MirConnection *connection;
- MirPixelFormat sw_pixel_format, hw_pixel_format;
- GdkMirDisplay *display;
- GDBusConnection *session;
- GError *error = NULL;
-
- connection = mir_connect_sync (NULL, g_get_prgname ());
- if (!connection)
- return NULL;
-
- if (!mir_connection_is_valid (connection))
- {
- mir_connection_release (connection);
- return NULL;
- }
-
- get_pixel_formats (connection, &sw_pixel_format, &hw_pixel_format);
-
- if (sw_pixel_format == mir_pixel_format_invalid ||
- hw_pixel_format == mir_pixel_format_invalid)
- {
- g_printerr ("Mir display does not support required pixel formats\n");
- mir_connection_release (connection);
- return NULL;
- }
-
- display = g_object_new (GDK_TYPE_MIR_DISPLAY, NULL);
-
- display->connection = connection;
- config_changed_cb (display->connection, display);
- mir_connection_set_display_config_change_callback (display->connection, config_changed_cb, display);
-
- GDK_DISPLAY (display)->device_manager = _gdk_mir_device_manager_new (GDK_DISPLAY (display));
- display->screen = _gdk_mir_screen_new (GDK_DISPLAY (display));
- display->sw_pixel_format = sw_pixel_format;
- display->hw_pixel_format = hw_pixel_format;
-
- session = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
-
- if (session == NULL)
- {
- g_error ("Error connecting to D-Bus session bus: %s", error->message);
- g_clear_error (&error);
- mir_connection_release (connection);
- return NULL;
- }
-
- display->content_service = content_hub_service_proxy_new_sync (
- session,
- G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES,
- "com.ubuntu.content.dbus.Service",
- "/",
- NULL,
- NULL);
-
- g_signal_connect_swapped (
- display->content_service,
- "pasteboard-changed",
- G_CALLBACK (pasteboard_changed_cb),
- display);
-
- display->content_handler = content_hub_handler_skeleton_new ();
-
- g_dbus_interface_skeleton_export (
- G_DBUS_INTERFACE_SKELETON (display->content_handler),
- session,
- "/org/gnome/gtk/content/handler",
- NULL);
-
- g_object_unref (session);
-
- content_hub_service_call_register_import_export_handler_sync (
- display->content_service,
- g_application_get_application_id (g_application_get_default ()),
- "/org/gnome/gtk/content/handler",
- NULL,
- NULL);
-
- content_hub_service_call_handler_active_sync (
- display->content_service,
- g_application_get_application_id (g_application_get_default ()),
- NULL,
- NULL);
-
- g_signal_emit_by_name (display, "opened");
-
- return GDK_DISPLAY (display);
-}
-
-/**
- * gdk_mir_display_get_mir_connection
- * @display: (type GdkMirDisplay): a #GdkDisplay
- *
- * Returns the #MirConnection for a #GdkDisplay
- *
- * Returns: (transfer none): a #MirConnection
- *
- * Since: 3.14
- */
-struct MirConnection *
-gdk_mir_display_get_mir_connection (GdkDisplay *display)
-{
- g_return_val_if_fail (GDK_IS_MIR_DISPLAY (display), NULL);
- return GDK_MIR_DISPLAY (display)->connection;
-}
-
-GdkMirEventSource *
-_gdk_mir_display_get_event_source (GdkDisplay *display)
-{
- g_return_val_if_fail (GDK_IS_MIR_DISPLAY (display), NULL);
-
- return GDK_MIR_DISPLAY (display)->event_source;
-}
-
-static void
-gdk_mir_display_dispose (GObject *object)
-{
- GdkMirDisplay *display = GDK_MIR_DISPLAY (object);
-
- g_clear_pointer (&display->paste_data, g_variant_unref);
- g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (display->content_handler));
- g_clear_object (&display->content_handler);
- g_clear_object (&display->content_service);
- g_clear_object (&display->screen);
- g_clear_object (&display->keymap);
- g_clear_pointer (&display->event_source, g_source_unref);
-
- g_list_free_full (display->monitors, g_object_unref);
- display->monitors = NULL;
-
- G_OBJECT_CLASS (gdk_mir_display_parent_class)->dispose (object);
-}
-
-static void
-gdk_mir_display_finalize (GObject *object)
-{
- GdkMirDisplay *display = GDK_MIR_DISPLAY (object);
-
- g_clear_pointer (&display->config, mir_display_config_release);
-
- mir_connection_release (display->connection);
-
- G_OBJECT_CLASS (gdk_mir_display_parent_class)->finalize (object);
-}
-
-static const gchar *
-gdk_mir_display_get_name (GdkDisplay *display)
-{
- return "Mir";
-}
-
-static GdkScreen *
-gdk_mir_display_get_default_screen (GdkDisplay *display)
-{
- return GDK_MIR_DISPLAY (display)->screen;
-}
-
-static void
-gdk_mir_display_beep (GdkDisplay *display)
-{
- /* No system level beep... */
-}
-
-static void
-gdk_mir_display_sync (GdkDisplay *display)
-{
-}
-
-static void
-gdk_mir_display_flush (GdkDisplay *display)
-{
-}
-
-static gboolean
-gdk_mir_display_has_pending (GdkDisplay *display)
-{
- /* We don't need to poll for events - so nothing pending */
- return FALSE;
-}
-
-static void
-gdk_mir_display_queue_events (GdkDisplay *display)
-{
- /* We don't need to poll for events - so don't do anything*/
-}
-
-static void
-gdk_mir_display_make_default (GdkDisplay *display)
-{
-}
-
-static GdkWindow *
-gdk_mir_display_get_default_group (GdkDisplay *display)
-{
- return NULL;
-}
-
-static gboolean
-gdk_mir_display_supports_shapes (GdkDisplay *display)
-{
- /* Mir doesn't support shaped windows */
- return FALSE;
-}
-
-static gboolean
-gdk_mir_display_supports_input_shapes (GdkDisplay *display)
-{
- return FALSE;
-}
-
-static gboolean
-gdk_mir_display_supports_cursor_alpha (GdkDisplay *display)
-{
- return FALSE;
-}
-
-static gboolean
-gdk_mir_display_supports_cursor_color (GdkDisplay *display)
-{
- return FALSE;
-}
-
-static void
-gdk_mir_display_get_default_cursor_size (GdkDisplay *display,
- guint *width,
- guint *height)
-{
- *width = *height = 32; // FIXME: Random value
-}
-
-static void
-gdk_mir_display_get_maximal_cursor_size (GdkDisplay *display,
- guint *width,
- guint *height)
-{
- *width = *height = 32; // FIXME: Random value
-}
-
-static GdkAppLaunchContext *
-gdk_mir_display_get_app_launch_context (GdkDisplay *display)
-{
- return NULL;
-}
-
-static gulong
-gdk_mir_display_get_next_serial (GdkDisplay *display)
-{
- return GDK_MIR_DISPLAY (display)->serial++;
-}
-
-static void
-gdk_mir_display_notify_startup_complete (GdkDisplay *display,
- const gchar *startup_id)
-{
-}
-
-static void
-gdk_mir_display_create_window_impl (GdkDisplay *display,
- GdkWindow *window,
- GdkWindow *real_parent,
- GdkEventMask event_mask,
- GdkWindowAttr *attributes)
-{
- if (attributes->wclass == GDK_INPUT_OUTPUT)
- {
- window->impl = _gdk_mir_window_impl_new (display, window);
- window->impl_window = window;
- }
- else /* attributes->wclass == GDK_INPUT_ONLY */
- {
- window->impl = g_object_ref (real_parent->impl);
- window->impl_window = real_parent;
-
- /* FIXME: this is called in gdk_window_new, which sets window->impl_window
- * back to window after this function returns. */
- }
-}
-
-static GdkKeymap *
-gdk_mir_display_get_keymap (GdkDisplay *display)
-{
- return GDK_MIR_DISPLAY (display)->keymap;
-}
-
-static void
-gdk_mir_display_push_error_trap (GdkDisplay *display)
-{
-}
-
-static gint
-gdk_mir_display_pop_error_trap (GdkDisplay *display,
- gboolean ignored)
-{
- return 0;
-}
-
-static gint
-gdk_mir_display_text_property_to_utf8_list (GdkDisplay *display,
- GdkAtom encoding,
- gint format,
- const guchar *text,
- gint length,
- gchar ***list)
-{
- GPtrArray *array;
- const gchar *ptr;
- gsize chunk_len;
- gchar *copy;
- guint nitems;
-
- ptr = (const gchar *) text;
- array = g_ptr_array_new ();
-
- /* split text into utf-8 strings */
- while (ptr < (const gchar *) &text[length])
- {
- chunk_len = strlen (ptr);
-
- if (g_utf8_validate (ptr, chunk_len, NULL))
- {
- copy = g_strndup (ptr, chunk_len);
- g_ptr_array_add (array, copy);
- }
-
- ptr = &ptr[chunk_len + 1];
- }
-
- nitems = array->len;
- g_ptr_array_add (array, NULL);
-
- if (list)
- *list = (gchar **) g_ptr_array_free (array, FALSE);
- else
- g_ptr_array_free (array, TRUE);
-
- return nitems;
-}
-
-static gchar *
-gdk_mir_display_utf8_to_string_target (GdkDisplay *display,
- const gchar *str)
-{
- return NULL;
-}
-
-static void
-get_pixel_formats (MirConnection *connection,
- MirPixelFormat *sw_pixel_format,
- MirPixelFormat *hw_pixel_format)
-{
- MirPixelFormat formats[mir_pixel_formats];
- unsigned int n_formats, i;
-
- mir_connection_get_available_surface_formats (connection, formats,
- mir_pixel_formats, &n_formats);
-
- if (sw_pixel_format)
- {
- *sw_pixel_format = mir_pixel_format_invalid;
-
- for (i = 0; i < n_formats && *sw_pixel_format == mir_pixel_format_invalid; i++)
- {
- switch (formats[i])
- {
- case mir_pixel_format_abgr_8888:
- case mir_pixel_format_xbgr_8888:
- case mir_pixel_format_argb_8888:
- case mir_pixel_format_xrgb_8888:
- case mir_pixel_format_rgb_565:
- *sw_pixel_format = formats[i];
- break;
- default:
- break;
- }
- }
- }
-
- if (hw_pixel_format)
- {
- *hw_pixel_format = mir_pixel_format_invalid;
-
- for (i = 0; i < n_formats && *hw_pixel_format == mir_pixel_format_invalid; i++)
- {
- switch (formats[i])
- {
- case mir_pixel_format_abgr_8888:
- case mir_pixel_format_xbgr_8888:
- case mir_pixel_format_argb_8888:
- case mir_pixel_format_xrgb_8888:
- case mir_pixel_format_rgb_565:
- *hw_pixel_format = formats[i];
- break;
- default:
- break;
- }
- }
- }
-}
-
-MirPixelFormat
-_gdk_mir_display_get_pixel_format (GdkDisplay *display,
- MirBufferUsage usage)
-{
- GdkMirDisplay *mir_dpy = GDK_MIR_DISPLAY (display);
-
- if (usage == mir_buffer_usage_hardware)
- return mir_dpy->hw_pixel_format;
-
- return mir_dpy->sw_pixel_format;
-}
-
-void
-_gdk_mir_display_focus_window (GdkDisplay *display,
- GdkWindow *window)
-{
- GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
-
- g_set_object (&mir_display->focused_window, window);
-}
-
-void
-_gdk_mir_display_unfocus_window (GdkDisplay *display,
- GdkWindow *window)
-{
- GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
-
- if (window == mir_display->focused_window)
- g_clear_object (&mir_display->focused_window);
-}
-
-void
-_gdk_mir_display_create_paste (GdkDisplay *display,
- const gchar * const *paste_formats,
- gconstpointer paste_data,
- gsize paste_size)
-{
- GdkMirDisplay *mir_display = GDK_MIR_DISPLAY (display);
- MirWindow *mir_window;
- MirWindowId *mir_window_id;
-
- if (!mir_display->focused_window)
- return;
-
- mir_window = _gdk_mir_window_get_mir_window (mir_display->focused_window);
-
- if (!mir_window)
- return;
-
- mir_window_id = mir_window_request_window_id_sync (mir_window);
-
- if (!mir_window_id)
- return;
-
- if (mir_window_id_is_valid (mir_window_id))
- content_hub_service_call_create_paste_sync (
- mir_display->content_service,
- g_application_get_application_id (g_application_get_default ()),
- mir_window_id_as_string (mir_window_id),
- g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, paste_data, paste_size, sizeof (guchar)),
- paste_formats,
- NULL,
- NULL,
- NULL);
-
- mir_window_id_release (mir_window_id);
-}
-
-gboolean
-_gdk_mir_display_init_egl_display (GdkDisplay *display)
-{
- GdkMirDisplay *mir_dpy = GDK_MIR_DISPLAY (display);
- EGLint major_version, minor_version;
- EGLDisplay *dpy;
-
- if (mir_dpy->egl_display)
- return TRUE;
-
- dpy = eglGetDisplay (mir_connection_get_egl_native_display (mir_dpy->connection));
- if (dpy == NULL)
- return FALSE;
-
- if (!eglInitialize (dpy, &major_version, &minor_version))
- return FALSE;
-
- if (!eglBindAPI (EGL_OPENGL_API))
- return FALSE;
-
- mir_dpy->egl_display = dpy;
-
- mir_dpy->have_egl_khr_create_context =
- epoxy_has_egl_extension (dpy, "EGL_KHR_create_context");
-
- mir_dpy->have_egl_buffer_age =
- epoxy_has_egl_extension (dpy, "EGL_EXT_buffer_age");
-
- mir_dpy->have_egl_swap_buffers_with_damage =
- epoxy_has_egl_extension (dpy, "EGL_EXT_swap_buffers_with_damage");
-
- mir_dpy->have_egl_surfaceless_context =
- epoxy_has_egl_extension (dpy, "EGL_KHR_surfaceless_context");
-
- GDK_NOTE (OPENGL,
- g_print ("EGL API version %d.%d found\n"
- " - Vendor: %s\n"
- " - Version: %s\n"
- " - Client APIs: %s\n"
- " - Extensions:\n"
- "\t%s\n",
- major_version,
- minor_version,
- eglQueryString (dpy, EGL_VENDOR),
- eglQueryString (dpy, EGL_VERSION),
- eglQueryString (dpy, EGL_CLIENT_APIS),
- eglQueryString (dpy, EGL_EXTENSIONS)));
-
- return TRUE;
-}
-
-static gboolean
-gdk_mir_display_make_gl_context_current (GdkDisplay *display,
- GdkGLContext *context)
-{
- EGLDisplay egl_display = _gdk_mir_display_get_egl_display (display);
- GdkMirGLContext *mir_context;
- GdkWindow *window;
- EGLSurface egl_surface;
-
- if (context == NULL)
- {
- eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
- return TRUE;
- }
-
- mir_context = GDK_MIR_GL_CONTEXT (context);
- window = gdk_gl_context_get_window (context);
-
- if (mir_context->is_attached || gdk_draw_context_is_drawing (GDK_DRAW_CONTEXT (context)))
- {
- egl_surface = _gdk_mir_window_get_egl_surface (window,
- mir_context->egl_config);
- }
- else
- {
- if (_gdk_mir_display_have_egl_surfaceless_context (display))
- egl_surface = EGL_NO_SURFACE;
- else
- egl_surface = _gdk_mir_window_get_dummy_egl_surface (window,
- mir_context->egl_config);
- }
-
- if (!eglMakeCurrent (egl_display, egl_surface, egl_surface, mir_context->egl_context))
- {
- g_warning ("eglMakeCurrent failed");
- return FALSE;
- }
-
- return TRUE;
-}
-
-EGLDisplay _gdk_mir_display_get_egl_display (GdkDisplay *display)
-{
- return GDK_MIR_DISPLAY (display)->egl_display;
-}
-
-gboolean _gdk_mir_display_have_egl_khr_create_context (GdkDisplay *display)
-{
- return GDK_MIR_DISPLAY (display)->have_egl_khr_create_context;
-}
-
-gboolean _gdk_mir_display_have_egl_buffer_age (GdkDisplay *display)
-{
- /* FIXME: this is not really supported by mir yet (despite is advertised) */
- // return GDK_MIR_DISPLAY (display)->have_egl_buffer_age;
- return FALSE;
-}
-
-gboolean _gdk_mir_display_have_egl_swap_buffers_with_damage (GdkDisplay *display)
-{
- /* FIXME: this is not really supported by mir yet (despite is advertised) */
- // return GDK_MIR_DISPLAY (display)->have_egl_swap_buffers_with_damage;
- return FALSE;
-}
-
-gboolean _gdk_mir_display_have_egl_surfaceless_context (GdkDisplay *display)
-{
- return GDK_MIR_DISPLAY (display)->have_egl_surfaceless_context;
-}
-
-static int
-gdk_mir_display_get_n_monitors (GdkDisplay *display)
-{
- return g_list_length (GDK_MIR_DISPLAY (display)->monitors);
-}
-
-static GdkMonitor *
-gdk_mir_display_get_monitor (GdkDisplay *display,
- int index)
-{
- g_return_val_if_fail (0 <= index && index < gdk_display_get_n_monitors (display), NULL);
-
- return g_list_nth_data (GDK_MIR_DISPLAY (display)->monitors, index);
-}
-
-static gboolean
-gdk_mir_display_get_setting (GdkDisplay *display,
- const char *name,
- GValue *value)
-{
- return gdk_mir_screen_get_setting (GDK_MIR_DISPLAY (display)->screen, name, value);
-}
-
-static void
-gdk_mir_display_init (GdkMirDisplay *display)
-{
- display->event_source = _gdk_mir_event_source_new (GDK_DISPLAY (display));
- display->keymap = _gdk_mir_keymap_new ();
-}
-
-static void
-gdk_mir_display_class_init (GdkMirDisplayClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GdkDisplayClass *display_class = GDK_DISPLAY_CLASS (klass);
-
- object_class->dispose = gdk_mir_display_dispose;
- object_class->finalize = gdk_mir_display_finalize;
-
- display_class->window_type = gdk_mir_window_get_type ();
-
- display_class->get_name = gdk_mir_display_get_name;
- display_class->get_default_screen = gdk_mir_display_get_default_screen;
- display_class->beep = gdk_mir_display_beep;
- display_class->sync = gdk_mir_display_sync;
- display_class->flush = gdk_mir_display_flush;
- display_class->has_pending = gdk_mir_display_has_pending;
- display_class->queue_events = gdk_mir_display_queue_events;
- display_class->make_default = gdk_mir_display_make_default;
- display_class->get_default_group = gdk_mir_display_get_default_group;
- display_class->supports_shapes = gdk_mir_display_supports_shapes;
- display_class->supports_input_shapes = gdk_mir_display_supports_input_shapes;
- display_class->supports_cursor_alpha = gdk_mir_display_supports_cursor_alpha;
- display_class->supports_cursor_color = gdk_mir_display_supports_cursor_color;
- display_class->get_default_cursor_size = gdk_mir_display_get_default_cursor_size;
- display_class->get_maximal_cursor_size = gdk_mir_display_get_maximal_cursor_size;
- display_class->get_app_launch_context = gdk_mir_display_get_app_launch_context;
- display_class->get_next_serial = gdk_mir_display_get_next_serial;
- display_class->notify_startup_complete = gdk_mir_display_notify_startup_complete;
- display_class->create_window_impl = gdk_mir_display_create_window_impl;
- display_class->get_keymap = gdk_mir_display_get_keymap;
- display_class->push_error_trap = gdk_mir_display_push_error_trap;
- display_class->pop_error_trap = gdk_mir_display_pop_error_trap;
- display_class->text_property_to_utf8_list = gdk_mir_display_text_property_to_utf8_list;
- display_class->utf8_to_string_target = gdk_mir_display_utf8_to_string_target;
- display_class->make_gl_context_current = gdk_mir_display_make_gl_context_current;
- display_class->get_n_monitors = gdk_mir_display_get_n_monitors;
- display_class->get_monitor = gdk_mir_display_get_monitor;
- display_class->get_setting = gdk_mir_display_get_setting;
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include "gdkinternals.h"
-#include "gdkdisplayprivate.h"
-#include "gdkmir.h"
-#include "gdkmir-private.h"
-
-#include <mir_toolkit/events/window_placement.h>
-
-#define NANO_TO_MILLI(x) ((x) / 1000000)
-
-struct _GdkMirWindowReference {
- GdkMirEventSource *source;
- GdkWindow *window;
- gint ref_count;
-};
-
-typedef struct {
- GdkMirWindowReference *window_ref;
- const MirEvent *event;
-} GdkMirQueuedEvent;
-
-struct _GdkMirEventSource
-{
- GSource parent_instance;
-
- GMutex mir_event_lock;
- GQueue mir_events;
- gboolean log_events;
-
- GdkDisplay *display;
-};
-
-static void
-send_event (GdkWindow *window, GdkDevice *device, GdkEvent *event)
-{
- GdkDisplay *display;
- GList *node;
-
- display = gdk_window_get_display (window);
-
- gdk_event_set_device (event, device);
- gdk_event_set_source_device (event, device);
- gdk_event_set_display (event, display);
- event->any.window = g_object_ref (window);
-
- node = _gdk_event_queue_append (display, event);
- _gdk_windowing_got_event (display, node, event, _gdk_display_get_next_serial (display));
-}
-
-static void
-set_key_event_string (GdkEventKey *event)
-{
- gunichar c = 0;
-
- if (event->keyval != GDK_KEY_VoidSymbol)
- c = gdk_keyval_to_unicode (event->keyval);
-
- if (c)
- {
- gchar buf[7];
- gint len;
- gsize bytes_written;
-
- /* Apply the control key - Taken from Xlib
- */
- if (event->state & GDK_CONTROL_MASK)
- {
- if ((c >= '@' && c < '\177') || c == ' ') c &= 0x1F;
- else if (c == '2')
- {
- event->string = g_memdup ("\0\0", 2);
- event->length = 1;
- buf[0] = '\0';
- return;
- }
- else if (c >= '3' && c <= '7') c -= ('3' - '\033');
- else if (c == '8') c = '\177';
- else if (c == '/') c = '_' & 0x1F;
- }
-
- len = g_unichar_to_utf8 (c, buf);
- buf[len] = '\0';
-
- event->string = g_locale_from_utf8 (buf, len,
- NULL, &bytes_written,
- NULL);
- if (event->string)
- event->length = bytes_written;
- }
- else if (event->keyval == GDK_KEY_Escape)
- {
- event->length = 1;
- event->string = g_strdup ("\033");
- }
- else if (event->keyval == GDK_KEY_Return ||
- event->keyval == GDK_KEY_KP_Enter)
- {
- event->length = 1;
- event->string = g_strdup ("\r");
- }
-
- if (!event->string)
- {
- event->length = 0;
- event->string = g_strdup ("");
- }
-}
-
-static void
-generate_key_event (GdkWindow *window, GdkEventType type, guint state, guint keyval, guint16 keycode, gboolean is_modifier, guint32 event_time)
-{
- GdkEvent *event;
- GdkDisplay *display;
- GdkSeat *seat;
- GdkDevice *keyboard;
-
- event = gdk_event_new (type);
- event->key.state = state;
- event->key.keyval = keyval;
- event->key.hardware_keycode = keycode + 8;
- gdk_event_set_scancode (event, keycode + 8);
- event->key.is_modifier = is_modifier;
- event->key.time = event_time;
- set_key_event_string (&event->key);
-
- display = gdk_window_get_display (window);
- seat = gdk_display_get_default_seat (display);
- keyboard = gdk_seat_get_keyboard (seat);
-
- send_event (window, keyboard, event);
-}
-
-static GdkDevice *
-get_pointer (GdkWindow *window)
-{
- GdkDisplay *display;
- GdkSeat *seat;
- GdkDevice *pointer;
-
- display = gdk_window_get_display (window);
- seat = gdk_display_get_default_seat (display);
- pointer = gdk_seat_get_pointer (seat);
-
- return pointer;
-}
-
-static void
-generate_button_event (GdkWindow *window, GdkEventType type, gdouble x, gdouble y, guint button, guint state, guint32 event_time)
-{
- GdkEvent *event;
-
- event = gdk_event_new (type);
- event->button.x = x;
- event->button.y = y;
- event->button.state = state;
- event->button.button = button;
- event->button.time = event_time;
-
- send_event (window, get_pointer (window), event);
-}
-
-static void
-generate_scroll_event (GdkWindow *window, gdouble x, gdouble y, gdouble delta_x, gdouble delta_y, guint state, guint32 event_time)
-{
- GdkEvent *event;
-
- event = gdk_event_new (GDK_SCROLL);
- event->scroll.x = x;
- event->scroll.y = y;
- event->scroll.state = state;
- event->scroll.time = event_time;
-
- if (ABS (delta_x) == 1 && delta_y == 0)
- {
- event->scroll.direction = (delta_x < 0) ? GDK_SCROLL_LEFT : GDK_SCROLL_RIGHT;
- }
- else if (ABS (delta_y) == 1 && delta_x == 0)
- {
- event->scroll.direction = (delta_y < 0) ? GDK_SCROLL_DOWN : GDK_SCROLL_UP;
- }
- else
- {
- event->scroll.direction = GDK_SCROLL_SMOOTH;
- event->scroll.delta_x = delta_x;
- event->scroll.delta_y = -delta_y;
- }
-
- send_event (window, get_pointer (window), event);
-}
-
-static void
-generate_motion_event (GdkWindow *window, gdouble x, gdouble y, guint state, guint32 event_time)
-{
- GdkEvent *event;
-
- event = gdk_event_new (GDK_MOTION_NOTIFY);
- event->motion.x = x;
- event->motion.y = y;
- event->motion.state = state;
- event->motion.is_hint = FALSE;
- event->motion.time = event_time;
-
- send_event (window, get_pointer (window), event);
-}
-
-static void
-generate_crossing_event (GdkWindow *window, GdkEventType type, gdouble x, gdouble y, guint32 event_time)
-{
- GdkEvent *event;
-
- event = gdk_event_new (type);
- event->crossing.x = x;
- event->crossing.y = y;
- event->crossing.mode = GDK_CROSSING_NORMAL;
- event->crossing.detail = GDK_NOTIFY_ANCESTOR;
- event->crossing.focus = TRUE;
- event->crossing.time = event_time;
-
- send_event (window, get_pointer (window), event);
-}
-
-static void
-generate_focus_event (GdkWindow *window, gboolean focused)
-{
- GdkEvent *event;
-
- if (focused)
- {
- gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FOCUSED);
- _gdk_mir_display_focus_window (gdk_window_get_display (window), window);
- }
- else
- {
- gdk_synthesize_window_state (window, GDK_WINDOW_STATE_FOCUSED, 0);
- _gdk_mir_display_unfocus_window (gdk_window_get_display (window), window);
- }
-
- event = gdk_event_new (GDK_FOCUS_CHANGE);
- event->focus_change.send_event = FALSE;
- event->focus_change.in = focused;
-
- send_event (window, get_pointer (window), event);
-}
-
-static guint
-get_modifier_state (unsigned int modifiers, guint button_state)
-{
- guint modifier_state = button_state;
-
- if ((modifiers & (mir_input_event_modifier_alt |
- mir_input_event_modifier_alt_left |
- mir_input_event_modifier_alt_right)) != 0)
- modifier_state |= GDK_MOD1_MASK;
- if ((modifiers & (mir_input_event_modifier_shift |
- mir_input_event_modifier_shift_left |
- mir_input_event_modifier_shift_right)) != 0)
- modifier_state |= GDK_SHIFT_MASK;
- if ((modifiers & (mir_input_event_modifier_ctrl |
- mir_input_event_modifier_ctrl_left |
- mir_input_event_modifier_ctrl_right)) != 0)
- modifier_state |= GDK_CONTROL_MASK;
- if ((modifiers & (mir_input_event_modifier_meta |
- mir_input_event_modifier_meta_left |
- mir_input_event_modifier_meta_right)) != 0)
- modifier_state |= GDK_META_MASK;
- if ((modifiers & mir_input_event_modifier_caps_lock) != 0)
- modifier_state |= GDK_LOCK_MASK;
-
- return modifier_state;
-}
-
-static void
-handle_key_event (GdkWindow *window, const MirInputEvent *event)
-{
- const MirKeyboardEvent *keyboard_event = mir_input_event_get_keyboard_event (event);
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- GdkKeymap *keymap;
- guint modifier_state;
- guint button_state;
-
- if (!keyboard_event)
- return;
-
- _gdk_mir_window_impl_get_cursor_state (impl, NULL, NULL, NULL, &button_state);
- modifier_state = get_modifier_state (mir_keyboard_event_modifiers (keyboard_event), button_state);
- keymap = gdk_display_get_keymap (gdk_window_get_display (window));
-
- generate_key_event (window,
- mir_keyboard_event_action (keyboard_event) == mir_keyboard_action_up ? GDK_KEY_RELEASE : GDK_KEY_PRESS,
- modifier_state,
- mir_keyboard_event_key_code (keyboard_event),
- mir_keyboard_event_scan_code (keyboard_event),
- _gdk_mir_keymap_key_is_modifier (keymap, mir_keyboard_event_key_code (keyboard_event)),
- NANO_TO_MILLI (mir_input_event_get_event_time (event)));
-}
-
-static void
-handle_touch_event (GdkWindow *window,
- const MirTouchEvent *mir_touch_event)
-{
- const MirInputEvent *mir_input_event = mir_touch_event_input_event (mir_touch_event);
- guint n = mir_touch_event_point_count (mir_touch_event);
- GdkEvent *gdk_event;
- guint i;
-
- for (i = 0; i < n; i++)
- {
- MirTouchAction action = mir_touch_event_action (mir_touch_event, i);
- if (action == mir_touch_action_up)
- gdk_event = gdk_event_new (GDK_TOUCH_END);
- else if (action == mir_touch_action_down)
- gdk_event = gdk_event_new (GDK_TOUCH_BEGIN);
- else
- gdk_event = gdk_event_new (GDK_TOUCH_UPDATE);
-
- gdk_event->touch.window = window;
- gdk_event->touch.sequence = GINT_TO_POINTER (mir_touch_event_id (mir_touch_event, i));
- gdk_event->touch.time = mir_input_event_get_event_time (mir_input_event);
- gdk_event->touch.state = get_modifier_state (mir_touch_event_modifiers (mir_touch_event), 0);
- gdk_event->touch.x = mir_touch_event_axis_value (mir_touch_event, i, mir_touch_axis_x);
- gdk_event->touch.y = mir_touch_event_axis_value (mir_touch_event, i, mir_touch_axis_y);
- gdk_event->touch.x_root = mir_touch_event_axis_value (mir_touch_event, i, mir_touch_axis_x);
- gdk_event->touch.y_root = mir_touch_event_axis_value (mir_touch_event, i, mir_touch_axis_y);
- gdk_event->touch.emulating_pointer = TRUE;
- gdk_event_set_pointer_emulated (gdk_event, TRUE);
-
- send_event (window, get_pointer (window), gdk_event);
- }
-}
-
-static guint
-get_button_state (const MirPointerEvent *event)
-{
- guint state = 0;
-
- if (mir_pointer_event_button_state (event, mir_pointer_button_primary)) /* left */
- state |= GDK_BUTTON1_MASK;
- if (mir_pointer_event_button_state (event, mir_pointer_button_secondary)) /* right */
- state |= GDK_BUTTON3_MASK;
- if (mir_pointer_event_button_state (event, mir_pointer_button_tertiary)) /* middle */
- state |= GDK_BUTTON2_MASK;
-
- return state;
-}
-
-static void
-handle_motion_event (GdkWindow *window, const MirInputEvent *event)
-{
- const MirPointerEvent *pointer_event = mir_input_event_get_pointer_event (event);
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- gdouble x, y;
- gboolean cursor_inside;
- guint button_state;
- guint new_button_state;
- guint modifier_state;
- guint32 event_time;
- GdkEventType event_type;
- guint changed_button_state;
-
- if (!pointer_event)
- return;
-
- _gdk_mir_window_impl_get_cursor_state (impl, &x, &y, &cursor_inside, &button_state);
- new_button_state = get_button_state (pointer_event);
- modifier_state = get_modifier_state (mir_pointer_event_modifiers (pointer_event), new_button_state);
- event_time = NANO_TO_MILLI (mir_input_event_get_event_time (event));
-
- if (window)
- {
- gdouble new_x;
- gdouble new_y;
- gdouble hscroll;
- gdouble vscroll;
-
- /* Update which window has focus */
- _gdk_mir_pointer_set_location (get_pointer (window), x, y, window, modifier_state);
- switch (mir_pointer_event_action (pointer_event))
- {
- case mir_pointer_action_button_up:
- case mir_pointer_action_button_down:
- event_type = mir_pointer_event_action (pointer_event) == mir_pointer_action_button_down ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE;
- changed_button_state = button_state ^ new_button_state;
- if (changed_button_state == 0 || (changed_button_state & GDK_BUTTON1_MASK) != 0)
- generate_button_event (window, event_type, x, y, GDK_BUTTON_PRIMARY, modifier_state, event_time);
- if ((changed_button_state & GDK_BUTTON2_MASK) != 0)
- generate_button_event (window, event_type, x, y, GDK_BUTTON_MIDDLE, modifier_state, event_time);
- if ((changed_button_state & GDK_BUTTON3_MASK) != 0)
- generate_button_event (window, event_type, x, y, GDK_BUTTON_SECONDARY, modifier_state, event_time);
- button_state = new_button_state;
- break;
- case mir_pointer_action_motion:
- new_x = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_x);
- new_y = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_y);
- hscroll = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_hscroll);
- vscroll = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_vscroll);
-
- if (hscroll != 0.0 || vscroll != 0.0)
- generate_scroll_event (window, x, y, hscroll, vscroll, modifier_state, event_time);
- if (ABS (new_x - x) > 0.5 || ABS (new_y - y) > 0.5)
- {
- generate_motion_event (window, new_x, new_y, modifier_state, event_time);
- x = new_x;
- y = new_y;
- }
-
- break;
- case mir_pointer_action_enter:
- if (!cursor_inside)
- {
- cursor_inside = TRUE;
- generate_crossing_event (window, GDK_ENTER_NOTIFY, x, y, event_time);
- }
- break;
- case mir_pointer_action_leave:
- if (cursor_inside)
- {
- cursor_inside = FALSE;
- generate_crossing_event (window, GDK_LEAVE_NOTIFY, x, y, event_time);
- }
- break;
- default:
- break;
- }
-
- _gdk_mir_window_impl_set_cursor_state (impl, x, y, cursor_inside, button_state);
- }
-}
-
-static void
-handle_window_event (GdkWindow *window,
- const MirWindowEvent *event)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- MirWindowState state;
-
- switch (mir_window_event_get_attribute (event))
- {
- case mir_window_attrib_type:
- _gdk_mir_window_impl_set_window_type (impl, mir_window_event_get_attribute_value (event));
- break;
- case mir_window_attrib_state:
- state = mir_window_event_get_attribute_value (event);
- _gdk_mir_window_impl_set_window_state (impl, state);
-
- switch (state)
- {
- case mir_window_state_restored:
- case mir_window_state_hidden:
- gdk_synthesize_window_state (window,
- GDK_WINDOW_STATE_ICONIFIED |
- GDK_WINDOW_STATE_MAXIMIZED |
- GDK_WINDOW_STATE_FULLSCREEN,
- 0);
- break;
- case mir_window_state_minimized:
- gdk_synthesize_window_state (window,
- GDK_WINDOW_STATE_MAXIMIZED |
- GDK_WINDOW_STATE_FULLSCREEN,
- GDK_WINDOW_STATE_ICONIFIED);
- break;
- case mir_window_state_maximized:
- case mir_window_state_vertmaximized:
- case mir_window_state_horizmaximized:
- gdk_synthesize_window_state (window,
- GDK_WINDOW_STATE_ICONIFIED |
- GDK_WINDOW_STATE_FULLSCREEN,
- GDK_WINDOW_STATE_MAXIMIZED);
- break;
- case mir_window_state_fullscreen:
- gdk_synthesize_window_state (window,
- GDK_WINDOW_STATE_ICONIFIED |
- GDK_WINDOW_STATE_MAXIMIZED,
- GDK_WINDOW_STATE_FULLSCREEN);
- break;
- default:
- break;
- }
-
- break;
- case mir_window_attrib_swapinterval:
- break;
- case mir_window_attrib_focus:
- generate_focus_event (window, mir_window_event_get_attribute_value (event) != 0);
- break;
- default:
- break;
- }
-}
-
-static void
-generate_configure_event (GdkWindow *window,
- gint width,
- gint height)
-{
- GdkEvent *event;
-
- event = gdk_event_new (GDK_CONFIGURE);
- event->configure.send_event = FALSE;
- event->configure.width = width;
- event->configure.height = height;
-
- send_event (window, get_pointer (window), event);
-}
-
-static void
-handle_resize_event (GdkWindow *window,
- const MirResizeEvent *event)
-{
- window->width = mir_resize_event_get_width (event);
- window->height = mir_resize_event_get_height (event);
- _gdk_window_update_size (window);
-
- generate_configure_event (window, mir_resize_event_get_width (event), mir_resize_event_get_height (event));
-}
-
-static void
-handle_close_event (GdkWindow *window)
-{
- send_event (window, get_pointer (window), gdk_event_new (GDK_DESTROY));
- gdk_window_destroy_notify (window);
-}
-
-static void
-handle_window_output_event (GdkWindow *window,
- const MirWindowOutputEvent *event)
-{
- _gdk_mir_window_set_scale (window, mir_window_output_event_get_scale (event));
-}
-
-static void
-handle_window_placement_event (GdkWindow *window,
- const MirWindowPlacementEvent *event)
-{
- _gdk_mir_window_set_final_rect (window, mir_window_placement_get_relative_position (event));
-}
-
-typedef struct
-{
- GdkWindow *window;
- MirEvent *event;
-} EventData;
-
-static void
-gdk_mir_event_source_queue_event (GdkDisplay *display,
- GdkWindow *window,
- const MirEvent *event)
-{
- const MirInputEvent *input_event;
-
- // FIXME: Only generate events if the window wanted them?
- switch (mir_event_get_type (event))
- {
- case mir_event_type_input:
- input_event = mir_event_get_input_event (event);
-
- switch (mir_input_event_get_type (input_event))
- {
- case mir_input_event_type_key:
- handle_key_event (window, input_event);
- break;
- case mir_input_event_type_touch:
- handle_touch_event (window, mir_input_event_get_touch_event (input_event));
- break;
- case mir_input_event_type_pointer:
- handle_motion_event (window, input_event);
- break;
- default:
- break;
- }
-
- break;
- case mir_event_type_key:
- handle_key_event (window, mir_event_get_input_event (event));
- break;
- case mir_event_type_motion:
- handle_motion_event (window, mir_event_get_input_event (event));
- break;
- case mir_event_type_window:
- handle_window_event (window, mir_event_get_window_event (event));
- break;
- case mir_event_type_resize:
- handle_resize_event (window, mir_event_get_resize_event (event));
- break;
- case mir_event_type_prompt_session_state_change:
- break;
- case mir_event_type_orientation:
- break;
- case mir_event_type_close_window:
- handle_close_event (window);
- break;
- case mir_event_type_keymap:
- break;
- case mir_event_type_window_output:
- handle_window_output_event (window, mir_event_get_window_output_event (event));
- break;
- case mir_event_type_input_device_state:
- break;
- case mir_event_type_window_placement:
- handle_window_placement_event (window, mir_event_get_window_placement_event (event));
- break;
- default:
- g_warning ("Ignoring unknown Mir event %d", mir_event_get_type (event));
- break;
- }
-}
-
-static GdkMirQueuedEvent *
-gdk_mir_event_source_take_queued_event (GdkMirEventSource *source)
-{
- GdkMirQueuedEvent *queued_event;
-
- g_mutex_lock (&source->mir_event_lock);
- queued_event = g_queue_pop_head (&source->mir_events);
- g_mutex_unlock (&source->mir_event_lock);
-
- return queued_event;
-}
-
-static void
-gdk_mir_queued_event_free (GdkMirQueuedEvent *event)
-{
- _gdk_mir_window_reference_unref (event->window_ref);
- mir_event_unref (event->event);
- g_slice_free (GdkMirQueuedEvent, event);
-}
-
-static void
-gdk_mir_event_source_convert_events (GdkMirEventSource *source)
-{
- GdkMirQueuedEvent *event;
-
- while ((event = gdk_mir_event_source_take_queued_event (source)))
- {
- GdkWindow *window = event->window_ref->window;
-
- /* The window may have been destroyed in the main thread while the
- * event was being dispatched...
- */
- if (window != NULL)
- {
- if (source->log_events)
- _gdk_mir_print_event (event->event);
-
- gdk_mir_event_source_queue_event (source->display, window, event->event);
- }
- else
- g_warning ("window was destroyed before event arrived...");
-
- gdk_mir_queued_event_free (event);
- }
-}
-
-static gboolean
-gdk_mir_event_source_prepare (GSource *g_source,
- gint *timeout)
-{
- GdkMirEventSource *source = (GdkMirEventSource *) g_source;
- gboolean mir_events_in_queue;
-
- if (_gdk_event_queue_find_first (source->display))
- return TRUE;
-
- g_mutex_lock (&source->mir_event_lock);
- mir_events_in_queue = g_queue_get_length (&source->mir_events) > 0;
- g_mutex_unlock (&source->mir_event_lock);
-
- return mir_events_in_queue;
-}
-
-static gboolean
-gdk_mir_event_source_check (GSource *g_source)
-{
- return gdk_mir_event_source_prepare (g_source, NULL);
-}
-
-static gboolean
-gdk_mir_event_source_dispatch (GSource *g_source,
- GSourceFunc callback,
- gpointer user_data)
-{
- GdkMirEventSource *source = (GdkMirEventSource *) g_source;
- GdkEvent *event;
-
- /* First, run the queue of events from the thread */
- gdk_mir_event_source_convert_events (source);
-
- /* Next, dispatch one single event from the display's queue.
- *
- * If there is more than one event then we will soon find ourselves
- * back here again.
- */
-
- event = gdk_display_get_event (source->display);
-
- if (event)
- {
- _gdk_event_emit (event);
-
- gdk_event_free (event);
- }
-
- return TRUE;
-}
-
-static void
-gdk_mir_event_source_finalize (GSource *g_source)
-{
- GdkMirEventSource *source = (GdkMirEventSource *) g_source;
- GdkMirQueuedEvent *event;
-
- while ((event = gdk_mir_event_source_take_queued_event (source)))
- gdk_mir_queued_event_free (event);
-
- g_mutex_clear (&source->mir_event_lock);
-}
-
-static GSourceFuncs gdk_mir_event_source_funcs = {
- gdk_mir_event_source_prepare,
- gdk_mir_event_source_check,
- gdk_mir_event_source_dispatch,
- gdk_mir_event_source_finalize
-};
-
-GdkMirEventSource *
-_gdk_mir_event_source_new (GdkDisplay *display)
-{
- GdkMirEventSource *source;
- GSource *g_source;
- char *name;
-
- g_source = g_source_new (&gdk_mir_event_source_funcs, sizeof (GdkMirEventSource));
- name = g_strdup_printf ("GDK Mir Event source (%s)", gdk_display_get_name (display));
- g_source_set_name (g_source, name);
- g_free (name);
- g_source_set_priority (g_source, GDK_PRIORITY_EVENTS);
- g_source_set_can_recurse (g_source, TRUE);
- g_source_attach (g_source, NULL);
-
- source = (GdkMirEventSource *) g_source;
- g_mutex_init (&source->mir_event_lock);
- source->display = display;
- source->log_events = (g_getenv ("GDK_MIR_LOG_EVENTS") != NULL);
-
- return source;
-}
-
-GdkMirWindowReference *
-_gdk_mir_event_source_get_window_reference (GdkWindow *window)
-{
- static GQuark win_ref_quark;
- GdkMirWindowReference *ref;
-
- if G_UNLIKELY (!win_ref_quark)
- win_ref_quark = g_quark_from_string ("GdkMirEventSource window reference");
-
- ref = g_object_get_qdata (G_OBJECT (window), win_ref_quark);
-
- if (!ref)
- {
- GdkMirEventSource *source;
-
- source = _gdk_mir_display_get_event_source (gdk_window_get_display (window));
- g_source_ref ((GSource *) source);
-
- ref = g_slice_new (GdkMirWindowReference);
- ref->window = window;
- ref->source = source;
- ref->ref_count = 0;
- g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &ref->window);
-
- g_object_set_qdata_full (G_OBJECT (window), win_ref_quark,
- ref, (GDestroyNotify) _gdk_mir_window_reference_unref);
- }
-
- g_atomic_int_inc (&ref->ref_count);
-
- return ref;
-}
-
-void
-_gdk_mir_window_reference_unref (GdkMirWindowReference *ref)
-{
- if (g_atomic_int_dec_and_test (&ref->ref_count))
- {
- if (ref->window)
- g_object_remove_weak_pointer (G_OBJECT (ref->window), (gpointer *) &ref->window);
-
- g_source_unref ((GSource *) ref->source);
-
- g_slice_free (GdkMirWindowReference, ref);
- }
-}
-
-void
-_gdk_mir_event_source_queue (GdkMirWindowReference *window_ref,
- const MirEvent *event)
-{
- GdkMirEventSource *source = window_ref->source;
- GdkMirQueuedEvent *queued_event;
-
- /* We are in the wrong thread right now. We absolutely cannot touch
- * the window.
- *
- * We can do pretty much anything we want with the source, though...
- */
-
- queued_event = g_slice_new (GdkMirQueuedEvent);
- g_atomic_int_inc (&window_ref->ref_count);
- queued_event->window_ref = window_ref;
- queued_event->event = mir_event_ref (event);
-
- g_mutex_lock (&source->mir_event_lock);
- g_queue_push_tail (&source->mir_events, queued_event);
- g_mutex_unlock (&source->mir_event_lock);
-
- g_main_context_wakeup (NULL);
-}
+++ /dev/null
-/* GDK - The GIMP Drawing Kit
- *
- * gdkmirglcontext.c: Mir specific OpenGL wrappers
- *
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include "gdkmir-private.h"
-#include "gdkinternals.h"
-#include "gdkintl.h"
-
-G_DEFINE_TYPE (GdkMirGLContext, gdk_mir_gl_context, GDK_TYPE_GL_CONTEXT)
-
-#define N_EGL_ATTRS 16
-
-static gboolean
-gdk_mir_gl_context_realize (GdkGLContext *context,
- GError **error)
-{
- GdkMirGLContext *context_mir = GDK_MIR_GL_CONTEXT (context);
- GdkDisplay *display = gdk_gl_context_get_display (context);
- GdkGLContext *share = gdk_gl_context_get_shared_context (context);
- EGLContext ctx;
- EGLint context_attribs[N_EGL_ATTRS];
- int major, minor, flags;
- gboolean debug_bit, forward_bit;
- int i = 0;
-
- if (!_gdk_mir_display_init_egl_display (display))
- {
- g_set_error_literal (error, GDK_GL_ERROR,
- GDK_GL_ERROR_NOT_AVAILABLE,
- _("No GL implementation is available"));
- return FALSE;
- }
-
- gdk_gl_context_get_required_version (context, &major, &minor);
- debug_bit = gdk_gl_context_get_debug_enabled (context);
- forward_bit = gdk_gl_context_get_forward_compatible (context);
-
- flags = 0;
-
- if (debug_bit)
- flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
- if (forward_bit)
- flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
-
- /* We want a core profile */
- context_attribs[i++] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR;
- context_attribs[i++] = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
-
- /* Specify the version */
- context_attribs[i++] = EGL_CONTEXT_MAJOR_VERSION_KHR;
- context_attribs[i++] = major;
- context_attribs[i++] = EGL_CONTEXT_MINOR_VERSION_KHR;
- context_attribs[i++] = minor;
-
- /* Specify the flags */
- context_attribs[i++] = EGL_CONTEXT_FLAGS_KHR;
- context_attribs[i++] = flags;
-
- context_attribs[i++] = EGL_NONE;
- g_assert (i < N_EGL_ATTRS);
-
- ctx = eglCreateContext (_gdk_mir_display_get_egl_display (display),
- context_mir->egl_config,
- share != NULL ? GDK_MIR_GL_CONTEXT (share)->egl_context
- : EGL_NO_CONTEXT,
- context_attribs);
- if (ctx == NULL)
- {
- g_set_error_literal (error, GDK_GL_ERROR,
- GDK_GL_ERROR_NOT_AVAILABLE,
- _("Unable to create a GL context"));
- return FALSE;
- }
-
- GDK_NOTE (OPENGL, g_print ("Created EGL context[%p]\n", ctx));
-
- context_mir->egl_context = ctx;
-
- return TRUE;
-}
-
-static cairo_region_t *
-gdk_mir_gl_context_get_damage (GdkGLContext *context)
-{
- GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
- EGLSurface egl_surface;
- GdkWindow *window = gdk_draw_context_get_window (GDK_DRAW_CONTEXT (context));
- int buffer_age = 0;
-
- if (_gdk_mir_display_have_egl_buffer_age (display))
- {
- GdkGLContext *shared;
- GdkMirGLContext *shared_mir;
-
- shared = gdk_gl_context_get_shared_context (context);
- if (shared == NULL)
- shared = context;
- shared_mir = GDK_MIR_GL_CONTEXT (shared);
-
- egl_surface = _gdk_mir_window_get_egl_surface (window, shared_mir->egl_config);
- gdk_gl_context_make_current (shared);
- eglQuerySurface (_gdk_mir_display_get_egl_display (display), egl_surface,
- EGL_BUFFER_AGE_EXT, &buffer_age);
-
- if (buffer_age >= 2)
- {
- if (window->old_updated_area[0])
- return cairo_region_copy (window->old_updated_area[0]);
- }
- else if (buffer_age >= 3)
- {
- if (window->old_updated_area[0] &&
- window->old_updated_area[1])
- {
- cairo_region_t *damage = cairo_region_copy (window->old_updated_area[0]);
- cairo_region_union (damage, window->old_updated_area[1]);
- return damage;
- }
- }
- }
-
- return GDK_GL_CONTEXT_CLASS (gdk_mir_gl_context_parent_class)->get_damage (context);
-}
-
-static void
-gdk_mir_gl_context_end_frame (GdkDrawContext *context,
- cairo_region_t *painted,
- cairo_region_t *damage)
-{
- GdkGLContext *gl_context = GDK_GL_CONTEXT (context);
- GdkMirGLContext *context_mir = GDK_MIR_GL_CONTEXT (gl_context);
- GdkWindow *window = gdk_gl_context_get_window (gl_context);
- GdkDisplay *display = gdk_window_get_display (window);
- EGLDisplay egl_display = _gdk_mir_display_get_egl_display (display);
- EGLSurface egl_surface;
-
- GDK_DRAW_CONTEXT_CLASS (gdk_mir_gl_context_parent_class)->end_frame (context, painted, damage);
- if (gdk_gl_context_get_shared_context (gl_context))
- return;
-
- gdk_gl_context_make_current (gl_context);
-
- egl_surface = _gdk_mir_window_get_egl_surface (window,
- context_mir->egl_config);
-
- if (_gdk_mir_display_have_egl_swap_buffers_with_damage (display))
- {
- int i, j, n_rects = cairo_region_num_rectangles (damage);
- EGLint *rects = g_new (EGLint, n_rects * 4);
- cairo_rectangle_int_t rect;
- int window_height = gdk_window_get_height (window);
-
- for (i = 0, j = 0; i < n_rects; i++)
- {
- cairo_region_get_rectangle (damage, i, &rect);
- rects[j++] = rect.x;
- rects[j++] = window_height - rect.height - rect.y;
- rects[j++] = rect.width;
- rects[j++] = rect.height;
- }
- eglSwapBuffersWithDamageEXT (egl_display, egl_surface, rects, n_rects);
- g_free (rects);
- }
- else
- {
- eglSwapBuffers (egl_display, egl_surface);
- }
-}
-
-static void
-gdk_mir_gl_context_dispose (GObject *gobject)
-{
- GdkMirGLContext *context_mir = GDK_MIR_GL_CONTEXT (gobject);
-
- if (context_mir->egl_context != NULL)
- {
- GdkGLContext *context = GDK_GL_CONTEXT (gobject);
- GdkWindow *window = gdk_gl_context_get_window (context);
- GdkDisplay *display = gdk_window_get_display (window);
- EGLDisplay egl_display = _gdk_mir_display_get_egl_display (display);
-
- if (eglGetCurrentContext () == context_mir->egl_context)
- eglMakeCurrent (egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-
- GDK_NOTE (OPENGL, g_print ("Destroying EGL context\n"));
-
- eglDestroyContext (egl_display, context_mir->egl_context);
- context_mir->egl_context = NULL;
- }
-
- G_OBJECT_CLASS (gdk_mir_gl_context_parent_class)->dispose (gobject);
-}
-
-static void
-gdk_mir_gl_context_class_init (GdkMirGLContextClass *klass)
-{
- GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
- GdkDrawContextClass *draw_context_class = GDK_DRAW_CONTEXT_CLASS (klass);
- GdkGLContextClass *gl_context_class = GDK_GL_CONTEXT_CLASS (klass);
-
- gl_context_class->realize = gdk_mir_gl_context_realize;
- gl_context_class->get_damage = gdk_mir_gl_context_get_damage;
- draw_context_class->end_frame = gdk_mir_gl_context_end_frame;
- gobject_class->dispose = gdk_mir_gl_context_dispose;
-}
-
-static void
-gdk_mir_gl_context_init (GdkMirGLContext *self)
-{
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include "gdkdeviceprivate.h"
-
-typedef struct GdkMirKeyboard GdkMirKeyboard;
-typedef struct GdkMirKeyboardClass GdkMirKeyboardClass;
-
-#define GDK_TYPE_MIR_KEYBOARD (gdk_mir_keyboard_get_type ())
-#define GDK_MIR_KEYBOARD(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_KEYBOARD, GdkMirKeyboard))
-#define GDK_MIR_KEYBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_KEYBOARD, GdkMirKeyboardClass))
-#define GDK_IS_MIR_KEYBOARD(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_KEYBOARD))
-#define GDK_IS_MIR_KEYBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_KEYBOARD))
-#define GDK_MIR_KEYBOARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_KEYBOARD, GdkMirKeyboardClass))
-
-struct GdkMirKeyboard
-{
- GdkDevice parent_instance;
-};
-
-struct GdkMirKeyboardClass
-{
- GdkDeviceClass parent_class;
-};
-
-G_DEFINE_TYPE (GdkMirKeyboard, gdk_mir_keyboard, GDK_TYPE_DEVICE)
-
-GdkDevice *
-_gdk_mir_keyboard_new (GdkDeviceManager *device_manager, const gchar *name)
-{
- return g_object_new (GDK_TYPE_MIR_KEYBOARD,
- "display", gdk_device_manager_get_display (device_manager),
- "device-manager", device_manager,
- "name", name,
- "type", GDK_DEVICE_TYPE_MASTER,
- "input-source", GDK_SOURCE_KEYBOARD,
- "input-mode", GDK_MODE_SCREEN,
- "has-cursor", FALSE,
- NULL);
-}
-
-static gboolean
-gdk_mir_keyboard_get_history (GdkDevice *device,
- GdkWindow *window,
- guint32 start,
- guint32 stop,
- GdkTimeCoord ***events,
- gint *n_events)
-{
- return FALSE;
-}
-
-static void
-gdk_mir_keyboard_get_state (GdkDevice *device,
- GdkWindow *window,
- gdouble *axes,
- GdkModifierType *mask)
-{
-}
-
-static void
-gdk_mir_keyboard_set_window_cursor (GdkDevice *device,
- GdkWindow *window,
- GdkCursor *cursor)
-{
- /* Keyboards don't have cursors... */
-}
-
-static void
-gdk_mir_keyboard_warp (GdkDevice *device,
- gdouble x,
- gdouble y)
-{
- /* Can't warp a keyboard... */
-}
-
-static void
-gdk_mir_keyboard_query_state (GdkDevice *device,
- GdkWindow *window,
- GdkWindow **child_window,
- gdouble *root_x,
- gdouble *root_y,
- gdouble *win_x,
- gdouble *win_y,
- GdkModifierType *mask)
-{
-}
-
-static GdkGrabStatus
-gdk_mir_keyboard_grab (GdkDevice *device,
- GdkWindow *window,
- gboolean owner_events,
- GdkEventMask event_mask,
- GdkWindow *confine_to,
- GdkCursor *cursor,
- guint32 time_)
-{
- /* Mir doesn't do grabs, so sure, you have the grab */
- return GDK_GRAB_SUCCESS;
-}
-
-static void
-gdk_mir_keyboard_ungrab (GdkDevice *device,
- guint32 time_)
-{
- /* Mir doesn't do grabs */
-}
-
-static GdkWindow *
-gdk_mir_keyboard_window_at_position (GdkDevice *device,
- gdouble *win_x,
- gdouble *win_y,
- GdkModifierType *mask,
- gboolean get_toplevel)
-{
- /* Keyboard don't have locations... */
- return NULL; // FIXME: Or the window with the keyboard focus?
-}
-
-static void
-gdk_mir_keyboard_select_window_events (GdkDevice *device,
- GdkWindow *window,
- GdkEventMask event_mask)
-{
-}
-
-static void
-gdk_mir_keyboard_init (GdkMirKeyboard *device)
-{
-}
-
-static void
-gdk_mir_keyboard_class_init (GdkMirKeyboardClass *klass)
-{
- GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
-
- device_class->get_history = gdk_mir_keyboard_get_history;
- device_class->get_state = gdk_mir_keyboard_get_state;
- device_class->set_window_cursor = gdk_mir_keyboard_set_window_cursor;
- device_class->warp = gdk_mir_keyboard_warp;
- device_class->query_state = gdk_mir_keyboard_query_state;
- device_class->grab = gdk_mir_keyboard_grab;
- device_class->ungrab = gdk_mir_keyboard_ungrab;
- device_class->window_at_position = gdk_mir_keyboard_window_at_position;
- device_class->select_window_events = gdk_mir_keyboard_select_window_events;
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include <xkbcommon/xkbcommon.h>
-
-#include "gdkkeysprivate.h"
-
-typedef struct GdkMirKeymap GdkMirKeymap;
-typedef struct GdkMirKeymapClass GdkMirKeymapClass;
-
-#define GDK_TYPE_MIR_KEYMAP (gdk_mir_keymap_get_type ())
-#define GDK_MIR_KEYMAP(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_KEYMAP, GdkMirKeymap))
-#define GDK_MIR_KEYMAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_KEYMAP, GdkMirKeymapClass))
-#define GDK_IS_MIR_KEYMAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_KEYMAP))
-#define GDK_IS_MIR_KEYMAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_KEYMAP))
-#define GDK_MIR_KEYMAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_KEYMAP, GdkMirKeymapClass))
-
-#define IsModifierKey(keysym) \
- (((keysym) >= XKB_KEY_Shift_L && (keysym) <= XKB_KEY_Hyper_R) || \
- ((keysym) >= XKB_KEY_ISO_Lock && (keysym) <= XKB_KEY_ISO_Last_Group_Lock) || \
- ((keysym) == XKB_KEY_Mode_switch) || \
- ((keysym) == XKB_KEY_Num_Lock))
-
-struct GdkMirKeymap
-{
- GdkKeymap parent_instance;
-
- struct xkb_keymap *xkb_keymap;
- struct xkb_state *xkb_state;
-
- PangoDirection *direction;
- gboolean bidi;
-};
-
-struct GdkMirKeymapClass
-{
- GdkKeymapClass parent_class;
-};
-
-G_DEFINE_TYPE (GdkMirKeymap, gdk_mir_keymap, GDK_TYPE_KEYMAP)
-
-GdkKeymap *
-_gdk_mir_keymap_new (void)
-{
- return g_object_new (GDK_TYPE_MIR_KEYMAP, NULL);
-}
-
-static PangoDirection
-gdk_mir_keymap_get_direction (GdkKeymap *keymap)
-{
- GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
- gint i;
-
- for (i = 0; i < xkb_keymap_num_layouts (mir_keymap->xkb_keymap); i++)
- {
- if (xkb_state_layout_index_is_active (mir_keymap->xkb_state, i, XKB_STATE_LAYOUT_EFFECTIVE))
- return mir_keymap->direction[i];
- }
-
- return PANGO_DIRECTION_NEUTRAL;
-}
-
-static gboolean
-gdk_mir_keymap_have_bidi_layouts (GdkKeymap *keymap)
-{
- return FALSE;
-}
-
-static gboolean
-gdk_mir_keymap_get_caps_lock_state (GdkKeymap *keymap)
-{
- return xkb_state_led_name_is_active (GDK_MIR_KEYMAP (keymap)->xkb_state, XKB_LED_NAME_CAPS);
-}
-
-static gboolean
-gdk_mir_keymap_get_num_lock_state (GdkKeymap *keymap)
-{
- return xkb_state_led_name_is_active (GDK_MIR_KEYMAP (keymap)->xkb_state, XKB_LED_NAME_NUM);
-}
-
-static gboolean
-gdk_mir_keymap_get_scroll_lock_state (GdkKeymap *keymap)
-{
- return xkb_state_led_name_is_active (GDK_MIR_KEYMAP (keymap)->xkb_state, XKB_LED_NAME_SCROLL);
-}
-
-static gboolean
-gdk_mir_keymap_get_entries_for_keyval (GdkKeymap *keymap,
- guint keyval,
- GdkKeymapKey **keys,
- gint *n_keys)
-{
- GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
- GArray *key_array;
- guint keycode;
-
- key_array = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));
-
- for (keycode = 8; keycode < 255; keycode++) /* FIXME: min/max keycode */
- {
- gint num_layouts, layout;
-
- num_layouts = xkb_keymap_num_layouts_for_key (mir_keymap->xkb_keymap, keycode);
- for (layout = 0; layout < num_layouts; layout++)
- {
- gint num_levels, level;
-
- num_levels = xkb_keymap_num_levels_for_key (mir_keymap->xkb_keymap, keycode, layout);
- for (level = 0; level < num_levels; level++)
- {
- const xkb_keysym_t *syms;
- gint num_syms, sym;
-
- num_syms = xkb_keymap_key_get_syms_by_level (mir_keymap->xkb_keymap, keycode, layout, level, &syms);
- for (sym = 0; sym < num_syms; sym++)
- {
- if (syms[sym] == keyval)
- {
- GdkKeymapKey key;
-
- key.keycode = keycode;
- key.group = layout;
- key.level = level;
-
- g_array_append_val (key_array, key);
- }
- }
- }
- }
- }
-
- *n_keys = key_array->len;
- *keys = (GdkKeymapKey*) g_array_free (key_array, FALSE);
-
- return TRUE;
-}
-
-static gboolean
-gdk_mir_keymap_get_entries_for_keycode (GdkKeymap *keymap,
- guint hardware_keycode,
- GdkKeymapKey **keys,
- guint **keyvals,
- gint *n_entries)
-{
- GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
- gint num_layouts, layout;
- gint num_entries;
- gint i;
-
- num_layouts = xkb_keymap_num_layouts_for_key (mir_keymap->xkb_keymap, hardware_keycode);
-
- num_entries = 0;
- for (layout = 0; layout < num_layouts; layout++)
- num_entries += xkb_keymap_num_levels_for_key (mir_keymap->xkb_keymap, hardware_keycode, layout);
-
- if (n_entries)
- *n_entries = num_entries;
- if (keys)
- *keys = g_new0 (GdkKeymapKey, num_entries);
- if (keyvals)
- *keyvals = g_new0 (guint, num_entries);
-
- i = 0;
- for (layout = 0; layout < num_layouts; layout++)
- {
- gint num_levels, level;
- num_levels = xkb_keymap_num_levels_for_key (mir_keymap->xkb_keymap, hardware_keycode, layout);
- for (level = 0; level < num_levels; level++)
- {
- const xkb_keysym_t *syms;
- int num_syms;
-
- num_syms = xkb_keymap_key_get_syms_by_level (mir_keymap->xkb_keymap, hardware_keycode, layout, 0, &syms);
- if (keys)
- {
- (*keys)[i].keycode = hardware_keycode;
- (*keys)[i].group = layout;
- (*keys)[i].level = level;
- }
- if (keyvals && num_syms > 0)
- (*keyvals)[i] = syms[0];
-
- i++;
- }
- }
-
- return num_entries > 0;
-}
-
-static guint
-gdk_mir_keymap_lookup_key (GdkKeymap *keymap,
- const GdkKeymapKey *key)
-{
- GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
- const xkb_keysym_t *syms;
- int num_syms;
-
- num_syms = xkb_keymap_key_get_syms_by_level (mir_keymap->xkb_keymap,
- key->keycode,
- key->group,
- key->level,
- &syms);
- if (num_syms > 0)
- return syms[0];
- else
- return XKB_KEY_NoSymbol;
-}
-
-static guint32
-get_xkb_modifiers (struct xkb_keymap *xkb_keymap,
- GdkModifierType state)
-{
- guint32 mods = 0;
-
- if (state & GDK_SHIFT_MASK)
- mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_SHIFT);
- if (state & GDK_LOCK_MASK)
- mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CAPS);
- if (state & GDK_CONTROL_MASK)
- mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CTRL);
- if (state & GDK_MOD1_MASK)
- mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_ALT);
- if (state & GDK_MOD2_MASK)
- mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod2");
- if (state & GDK_MOD3_MASK)
- mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod3");
- if (state & GDK_MOD4_MASK)
- mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_LOGO);
- if (state & GDK_MOD5_MASK)
- mods |= 1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod5");
-
- return mods;
-}
-
-static GdkModifierType
-get_gdk_modifiers (struct xkb_keymap *xkb_keymap,
- guint32 mods)
-{
- GdkModifierType state = 0;
-
- if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_SHIFT)))
- state |= GDK_SHIFT_MASK;
- if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CAPS)))
- state |= GDK_LOCK_MASK;
- if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_CTRL)))
- state |= GDK_CONTROL_MASK;
- if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_ALT)))
- state |= GDK_MOD1_MASK;
- if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod2")))
- state |= GDK_MOD2_MASK;
- if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod3")))
- state |= GDK_MOD3_MASK;
- if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, XKB_MOD_NAME_LOGO)))
- state |= GDK_MOD4_MASK;
- if (mods & (1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod5")))
- state |= GDK_MOD5_MASK;
-
- return state;
-}
-
-static gboolean
-gdk_mir_keymap_translate_keyboard_state (GdkKeymap *keymap,
- guint hardware_keycode,
- GdkModifierType state,
- gint group,
- guint *keyval,
- gint *effective_group,
- gint *effective_level,
- GdkModifierType *consumed_modifiers)
-{
- GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
- struct xkb_state *xkb_state;
- guint32 modifiers;
- guint32 consumed;
- xkb_layout_index_t layout;
- xkb_level_index_t level;
- xkb_keysym_t sym;
-
- modifiers = get_xkb_modifiers (mir_keymap->xkb_keymap, state);
-
- xkb_state = xkb_state_new (mir_keymap->xkb_keymap);
-
- xkb_state_update_mask (xkb_state, modifiers, 0, 0, group, 0, 0);
-
- layout = xkb_state_key_get_layout (xkb_state, hardware_keycode);
- level = xkb_state_key_get_level (xkb_state, hardware_keycode, layout);
- sym = xkb_state_key_get_one_sym (xkb_state, hardware_keycode);
- consumed = modifiers & ~xkb_state_mod_mask_remove_consumed (xkb_state, hardware_keycode, modifiers);
-
- xkb_state_unref (xkb_state);
-
- if (keyval)
- *keyval = sym;
- if (effective_group)
- *effective_group = layout;
- if (effective_level)
- *effective_level = level;
- if (consumed_modifiers)
- *consumed_modifiers = get_gdk_modifiers (mir_keymap->xkb_keymap, consumed);
-
- return TRUE;
-}
-
-static void
-gdk_mir_keymap_add_virtual_modifiers (GdkKeymap *keymap,
- GdkModifierType *state)
-{
- // FIXME: What is this?
-}
-
-static gboolean
-gdk_mir_keymap_map_virtual_modifiers (GdkKeymap *keymap,
- GdkModifierType *state)
-{
- // FIXME: What is this?
- return TRUE;
-}
-
-static guint
-gdk_mir_keymap_get_modifier_state (GdkKeymap *keymap)
-{
- GdkMirKeymap *mir_keymap = GDK_MIR_KEYMAP (keymap);
- xkb_mod_mask_t mods;
-
- mods = xkb_state_serialize_mods (mir_keymap->xkb_state, XKB_STATE_MODS_EFFECTIVE);
-
- return get_gdk_modifiers (mir_keymap->xkb_keymap, mods);
-}
-
-gboolean
-_gdk_mir_keymap_key_is_modifier (GdkKeymap *keymap,
- guint keycode)
-{
- // FIXME: use xkb_state
- return IsModifierKey (keycode);
-}
-
-static void
-update_direction (GdkMirKeymap *keymap)
-{
- gint num_layouts;
- gint *rtl;
- guint key;
- gboolean have_rtl, have_ltr;
- gint i;
-
- num_layouts = xkb_keymap_num_layouts (keymap->xkb_keymap);
-
- g_free (keymap->direction);
- keymap->direction = g_new0 (PangoDirection, num_layouts);
-
- rtl = g_new0 (gint, num_layouts);
-
- for (key = 8; key < 255; key++) /* FIXME: min/max keycode */
- {
- gint layouts;
- gint layout;
-
- layouts = xkb_keymap_num_layouts_for_key (keymap->xkb_keymap, key);
- for (layout = 0; layout < layouts; layout++)
- {
- const xkb_keysym_t *syms;
- gint num_syms;
- gint sym;
-
- num_syms = xkb_keymap_key_get_syms_by_level (keymap->xkb_keymap, key, layout, 0, &syms);
- for (sym = 0; sym < num_syms; sym++)
- {
- PangoDirection dir;
- dir = pango_unichar_direction (xkb_keysym_to_utf32 (syms[sym]));
- switch (dir)
- {
- case PANGO_DIRECTION_RTL:
- rtl[layout]++;
- break;
- case PANGO_DIRECTION_LTR:
- rtl[layout]--;
- break;
- default:
- break;
- }
- }
- }
- }
-
- have_rtl = have_ltr = FALSE;
- for (i = 0; i < num_layouts; i++)
- {
- if (rtl[i] > 0)
- {
- keymap->direction[i] = PANGO_DIRECTION_RTL;
- have_rtl = TRUE;
- }
- else
- {
- keymap->direction[i] = PANGO_DIRECTION_LTR;
- have_ltr = TRUE;
- }
- }
-
- if (have_rtl && have_ltr)
- keymap->bidi = TRUE;
-
- g_free (rtl);
-}
-
-static void
-gdk_mir_keymap_init (GdkMirKeymap *keymap)
-{
- struct xkb_context *context;
- struct xkb_rule_names names;
-
- context = xkb_context_new (0);
-
- names.rules = "evdev";
- names.model = "pc105";
- names.layout = "us";
- names.variant = "";
- names.options = "";
- keymap->xkb_keymap = xkb_keymap_new_from_names (context, &names, 0);
- keymap->xkb_state = xkb_state_new (keymap->xkb_keymap);
-
- xkb_context_unref (context);
-
- update_direction (keymap);
-}
-
-static void
-gdk_mir_keymap_finalize (GObject *object)
-{
- GdkMirKeymap *keymap = GDK_MIR_KEYMAP (object);
-
- xkb_keymap_unref (keymap->xkb_keymap);
- xkb_state_unref (keymap->xkb_state);
- g_free (keymap->direction);
-
- G_OBJECT_CLASS (gdk_mir_keymap_parent_class)->finalize (object);
-}
-
-static void
-gdk_mir_keymap_class_init (GdkMirKeymapClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GdkKeymapClass *keymap_class = GDK_KEYMAP_CLASS (klass);
-
- object_class->finalize = gdk_mir_keymap_finalize;
-
- keymap_class->get_direction = gdk_mir_keymap_get_direction;
- keymap_class->have_bidi_layouts = gdk_mir_keymap_have_bidi_layouts;
- keymap_class->get_caps_lock_state = gdk_mir_keymap_get_caps_lock_state;
- keymap_class->get_num_lock_state = gdk_mir_keymap_get_num_lock_state;
- keymap_class->get_scroll_lock_state = gdk_mir_keymap_get_scroll_lock_state;
- keymap_class->get_entries_for_keyval = gdk_mir_keymap_get_entries_for_keyval;
- keymap_class->get_entries_for_keycode = gdk_mir_keymap_get_entries_for_keycode;
- keymap_class->lookup_key = gdk_mir_keymap_lookup_key;
- keymap_class->translate_keyboard_state = gdk_mir_keymap_translate_keyboard_state;
- keymap_class->add_virtual_modifiers = gdk_mir_keymap_add_virtual_modifiers;
- keymap_class->map_virtual_modifiers = gdk_mir_keymap_map_virtual_modifiers;
- keymap_class->get_modifier_state = gdk_mir_keymap_get_modifier_state;
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include "gdkdisplayprivate.h"
-#include "gdkdeviceprivate.h"
-#include "gdkscreen.h"
-#include "gdkwindow.h"
-
-typedef struct GdkMirPointer GdkMirPointer;
-typedef struct GdkMirPointerClass GdkMirPointerClass;
-
-#define GDK_TYPE_MIR_POINTER (gdk_mir_pointer_get_type ())
-#define GDK_MIR_POINTER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_POINTER, GdkMirPointer))
-#define GDK_MIR_POINTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_POINTER, GdkMirPointerClass))
-#define GDK_IS_MIR_POINTER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_POINTER))
-#define GDK_IS_MIR_POINTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_POINTER))
-#define GDK_MIR_POINTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_POINTER, GdkMirPointerClass))
-
-struct GdkMirPointer
-{
- GdkDevice parent_instance;
-
- /* Location of pointer */
- gdouble x;
- gdouble y;
-
- /* Window this pointer is over */
- GdkWindow *over_window;
-
- /* Current modifier mask */
- GdkModifierType modifier_mask;
-};
-
-struct GdkMirPointerClass
-{
- GdkDeviceClass parent_class;
-};
-
-G_DEFINE_TYPE (GdkMirPointer, gdk_mir_pointer, GDK_TYPE_DEVICE)
-
-GdkDevice *
-_gdk_mir_pointer_new (GdkDeviceManager *device_manager, const gchar *name)
-{
- return g_object_new (GDK_TYPE_MIR_POINTER,
- "display", gdk_device_manager_get_display (device_manager),
- "device-manager", device_manager,
- "name", name,
- "type", GDK_DEVICE_TYPE_MASTER,
- "input-source", GDK_SOURCE_MOUSE,
- "input-mode", GDK_MODE_SCREEN,
- "has-cursor", TRUE,
- NULL);
-}
-
-void
-_gdk_mir_pointer_set_location (GdkDevice *pointer,
- gdouble x,
- gdouble y,
- GdkWindow *window,
- GdkModifierType mask)
-{
- GdkMirPointer *p = GDK_MIR_POINTER (pointer);
-
- p->x = x;
- p->y = y;
- if (p->over_window)
- g_object_unref (p->over_window);
- p->over_window = g_object_ref (window);
- p->modifier_mask = mask;
-}
-
-static gboolean
-gdk_mir_pointer_get_history (GdkDevice *device,
- GdkWindow *window,
- guint32 start,
- guint32 stop,
- GdkTimeCoord ***events,
- gint *n_events)
-{
- return FALSE;
-}
-
-static void
-gdk_mir_pointer_get_state (GdkDevice *device,
- GdkWindow *window,
- gdouble *axes,
- GdkModifierType *mask)
-{
- GdkMirPointer *p = GDK_MIR_POINTER (device);
- gdouble x, y;
-
- gdk_window_get_device_position_double (window, device, &x, &y, mask);
- if (axes)
- {
- axes[0] = p->x;
- axes[1] = p->y;
- }
-}
-
-static void
-gdk_mir_pointer_set_window_cursor (GdkDevice *device,
- GdkWindow *window,
- GdkCursor *cursor)
-{
- /* Mir doesn't support cursors */
-}
-
-static void
-gdk_mir_pointer_warp (GdkDevice *device,
- gdouble x,
- gdouble y)
-{
- /* Mir doesn't support warping */
-}
-
-static void
-gdk_mir_pointer_query_state (GdkDevice *device,
- GdkWindow *window,
- GdkWindow **child_window,
- gdouble *root_x,
- gdouble *root_y,
- gdouble *win_x,
- gdouble *win_y,
- GdkModifierType *mask)
-{
- GdkMirPointer *p = GDK_MIR_POINTER (device);
-
- if (child_window)
- *child_window = p->over_window;
- if (root_x)
- *root_x = p->x;
- if (root_y)
- *root_y = p->y;
- if (win_x)
- *win_x = p->x; // FIXME
- if (win_y)
- *win_y = p->y;
- if (mask)
- *mask = p->modifier_mask;
-}
-
-static GdkGrabStatus
-gdk_mir_pointer_grab (GdkDevice *device,
- GdkWindow *window,
- gboolean owner_events,
- GdkEventMask event_mask,
- GdkWindow *confine_to,
- GdkCursor *cursor,
- guint32 time_)
-{
- /* Mir doesn't do grabs, so sure, you have the grab */
- return GDK_GRAB_SUCCESS;
-}
-
-static void
-gdk_mir_pointer_ungrab (GdkDevice *device,
- guint32 time_)
-{
- /* Mir doesn't do grabs */
-
- GdkDeviceGrabInfo *grab = _gdk_display_get_last_device_grab (gdk_device_get_display (device), device);
-
- if (grab)
- grab->serial_end = grab->serial_start;
-}
-
-static GdkWindow *
-gdk_mir_pointer_window_at_position (GdkDevice *device,
- gdouble *win_x,
- gdouble *win_y,
- GdkModifierType *mask,
- gboolean get_toplevel)
-{
- GdkMirPointer *p = GDK_MIR_POINTER (device);
-
- if (win_x)
- *win_x = p->x;
- if (win_y)
- *win_y = p->y;
- if (mask)
- *mask = p->modifier_mask;
-
- return p->over_window;
-}
-
-static void
-gdk_mir_pointer_select_window_events (GdkDevice *device,
- GdkWindow *window,
- GdkEventMask event_mask)
-{
- // FIXME?
-}
-
-static void
-gdk_mir_pointer_init (GdkMirPointer *device)
-{
-}
-
-static void
-gdk_mir_pointer_finalize (GObject *object)
-{
- GdkMirPointer *p = GDK_MIR_POINTER (object);
-
- if (p->over_window)
- g_object_unref (p->over_window);
-
- G_OBJECT_CLASS (gdk_mir_pointer_parent_class)->finalize (object);
-}
-
-static void
-gdk_mir_pointer_class_init (GdkMirPointerClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
-
- object_class->finalize = gdk_mir_pointer_finalize;
-
- device_class->get_history = gdk_mir_pointer_get_history;
- device_class->get_state = gdk_mir_pointer_get_state;
- device_class->set_window_cursor = gdk_mir_pointer_set_window_cursor;
- device_class->warp = gdk_mir_pointer_warp;
- device_class->query_state = gdk_mir_pointer_query_state;
- device_class->grab = gdk_mir_pointer_grab;
- device_class->ungrab = gdk_mir_pointer_ungrab;
- device_class->window_at_position = gdk_mir_pointer_window_at_position;
- device_class->select_window_events = gdk_mir_pointer_select_window_events;
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <string.h>
-
-#include "gdkscreenprivate.h"
-#include "gdkdisplayprivate.h"
-#include "gdkinternals.h"
-
-#include "gdkmir.h"
-#include "gdkmir-private.h"
-
-#define VISUAL_TYPE GDK_VISUAL_TRUE_COLOR
-
-typedef struct GdkMirScreen GdkMirScreen;
-typedef struct GdkMirScreenClass GdkMirScreenClass;
-
-#define GDK_TYPE_MIR_SCREEN (gdk_mir_screen_get_type ())
-#define GDK_MIR_SCREEN(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MIR_SCREEN, GdkMirScreen))
-#define GDK_MIR_SCREEN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MIR_SCREEN, GdkMirScreenClass))
-#define GDK_IS_MIR_SCREEN(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MIR_SCREEN))
-#define GDK_IS_MIR_SCREEN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_SCREEN))
-#define GDK_MIR_SCREEN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_SCREEN, GdkMirScreenClass))
-
-struct GdkMirScreen
-{
- GdkScreen parent_instance;
-
- /* Display this screen is running on */
- GdkDisplay *display;
-
- /* Current monitor configuration */
- MirDisplayConfig *display_config;
-
- /* Root window */
- GdkWindow *root_window;
-
- /* Settings */
- GHashTable *settings_objects;
- GHashTable *current_settings;
-};
-
-struct GdkMirScreenClass
-{
- GdkScreenClass parent_class;
-};
-
-G_DEFINE_TYPE (GdkMirScreen, gdk_mir_screen, GDK_TYPE_SCREEN)
-
-static MirConnection *
-get_connection (GdkMirScreen *screen)
-{
- return gdk_mir_display_get_mir_connection (GDK_DISPLAY (screen->display));
-}
-
-static void
-get_screen_size (MirDisplayConfig *config,
- gint *width,
- gint *height)
-{
- const MirOutput *output;
- const MirOutputMode *mode;
- gint right;
- gint bottom;
- gint i;
-
- *width = 0;
- *height = 0;
-
- if (!config)
- return;
-
- for (i = 0; i < mir_display_config_get_num_outputs (config); i++)
- {
- output = mir_display_config_get_output (config, i);
-
- if (!mir_output_is_enabled (output))
- continue;
-
- mode = mir_output_get_current_mode (output);
-
- right = mir_output_get_position_x (output) + mir_output_mode_get_width (mode);
- bottom = mir_output_get_position_y (output) + mir_output_mode_get_height (mode);
-
- if (right > *width)
- *width = right;
-
- if (bottom > *height)
- *height = bottom;
- }
-}
-
-static void
-update_display_config (GdkMirScreen *screen)
-{
- gdk_mir_display_get_mir_connection (GDK_DISPLAY (screen->display));
- mir_display_config_release (screen->display_config);
- screen->display_config = mir_connection_create_display_configuration (get_connection (screen));
-}
-
-static void
-config_changed_cb (MirConnection *connection, void *data)
-{
- GdkMirScreen *screen = data;
-
- update_display_config (screen);
-}
-
-GdkScreen *
-_gdk_mir_screen_new (GdkDisplay *display)
-{
- GdkMirScreen *screen;
-
- screen = g_object_new (GDK_TYPE_MIR_SCREEN, NULL);
- screen->display = display;
- mir_connection_set_display_config_change_callback (get_connection (screen), config_changed_cb, screen);
- update_display_config (screen);
-
- return GDK_SCREEN (screen);
-}
-
-static void
-gdk_mir_screen_dispose (GObject *object)
-{
- GdkMirScreen *screen = GDK_MIR_SCREEN (object);
-
- g_clear_pointer (&screen->current_settings, g_hash_table_unref);
- g_clear_pointer (&screen->settings_objects, g_hash_table_unref);
-
- G_OBJECT_CLASS (gdk_mir_screen_parent_class)->dispose (object);
-}
-
-static void
-gdk_mir_screen_finalize (GObject *object)
-{
- GdkMirScreen *screen = GDK_MIR_SCREEN (object);
-
- mir_connection_set_display_config_change_callback (get_connection (screen), NULL, NULL);
- mir_display_config_release (screen->display_config);
- g_clear_object (&screen->root_window);
-
- G_OBJECT_CLASS (gdk_mir_screen_parent_class)->finalize (object);
-}
-
-static GdkDisplay *
-gdk_mir_screen_get_display (GdkScreen *screen)
-{
- return GDK_DISPLAY (GDK_MIR_SCREEN (screen)->display);
-}
-
-static GdkWindow *
-gdk_mir_screen_get_root_window (GdkScreen *screen)
-{
- GdkMirScreen *s = GDK_MIR_SCREEN (screen);
- gint width, height;
-
- if (s->root_window)
- return s->root_window;
-
- get_screen_size (GDK_MIR_SCREEN (screen)->display_config, &width, &height);
-
- s->root_window = _gdk_display_create_window (s->display);
- s->root_window->impl_window = s->root_window;
- s->root_window->window_type = GDK_WINDOW_ROOT;
- s->root_window->x = 0;
- s->root_window->y = 0;
- s->root_window->abs_x = 0;
- s->root_window->abs_y = 0;
- s->root_window->width = width;
- s->root_window->height = height;
- s->root_window->viewable = TRUE;
- s->root_window->impl = _gdk_mir_window_impl_new (s->display, s->root_window);
-
- return s->root_window;
-}
-
-static void setting_changed (GSettings *settings,
- const gchar *key,
- GdkMirScreen *screen);
-
-static GSettings *
-get_settings (GdkMirScreen *screen,
- const gchar *schema_id)
-{
- GSettings *settings;
- GSettingsSchemaSource *source;
- GSettingsSchema *schema;
-
- settings = g_hash_table_lookup (screen->settings_objects, schema_id);
-
- if (settings)
- return g_object_ref (settings);
-
- source = g_settings_schema_source_get_default ();
-
- if (!source)
- {
- g_warning ("no schemas installed");
- return NULL;
- }
-
- schema = g_settings_schema_source_lookup (source, schema_id, TRUE);
-
- if (!schema)
- {
- g_warning ("schema not found: %s", schema_id);
- return NULL;
- }
-
- settings = g_settings_new_full (schema, NULL, NULL);
- g_signal_connect (settings, "changed", G_CALLBACK (setting_changed), screen);
- g_hash_table_insert (screen->settings_objects, g_strdup (schema_id), g_object_ref (settings));
- g_settings_schema_unref (schema);
- return settings;
-}
-
-static GVariant *
-read_setting (GdkMirScreen *screen,
- const gchar *schema_id,
- const gchar *key)
-{
- GSettings *settings;
- GVariant *variant;
-
- settings = get_settings (screen, schema_id);
-
- if (!settings)
- return NULL;
-
- variant = g_settings_get_value (settings, key);
- g_object_unref (settings);
- return variant;
-}
-
-static void
-change_setting (GdkMirScreen *screen,
- const gchar *name,
- GVariant *variant)
-{
- GVariant *old_variant;
-
- old_variant = g_hash_table_lookup (screen->current_settings, name);
-
- if (variant == old_variant)
- return;
-
- if (variant && old_variant && g_variant_equal (variant, old_variant))
- return;
-
- if (variant)
- g_hash_table_insert (screen->current_settings, g_strdup (name), g_variant_ref_sink (variant));
- else
- g_hash_table_remove (screen->current_settings, name);
-
- gdk_display_setting_changed (GDK_DISPLAY (GDK_MIR_SCREEN (screen)->display), name);
-}
-
-static const struct
-{
- const gchar *name;
- const gchar *schema_id;
- const gchar *key;
-} SETTINGS_MAP[] = {
- {
- "gtk-double-click-time",
- "org.gnome.settings-daemon.peripherals.mouse",
- "double-click"
- },
- {
- "gtk-cursor-blink",
- "org.gnome.desktop.interface",
- "cursor-blink"
- },
- {
- "gtk-cursor-blink-time",
- "org.gnome.desktop.interface",
- "cursor-blink-time"
- },
- {
- "gtk-cursor-blink-timeout",
- "org.gnome.desktop.interface",
- "cursor-blink-timeout"
- },
- {
- "gtk-theme-name",
- "org.gnome.desktop.interface",
- "gtk-theme"
- },
- {
- "gtk-icon-theme-name",
- "org.gnome.desktop.interface",
- "icon-theme"
- },
- {
- "gtk-key-theme-name",
- "org.gnome.desktop.interface",
- "gtk-key-theme"
- },
- {
- "gtk-dnd-drag-threshold",
- "org.gnome.settings-daemon.peripherals.mouse",
- "drag-threshold"
- },
- {
- "gtk-font-name",
- "org.gnome.desktop.interface",
- "font-name"
- },
- {
- "gtk-xft-antialias",
- "org.gnome.settings-daemon.plugins.xsettings",
- "antialiasing"
- },
- {
- "gtk-xft-hinting",
- "org.gnome.settings-daemon.plugins.xsettings",
- "hinting"
- },
- {
- "gtk-xft-hintstyle",
- "org.gnome.settings-daemon.plugins.xsettings",
- "hinting"
- },
- {
- "gtk-xft-rgba",
- "org.gnome.settings-daemon.plugins.xsettings",
- "rgba-order"
- },
- {
- "gtk-xft-dpi",
- "org.gnome.desktop.interface",
- "text-scaling-factor"
- },
- {
- "gtk-cursor-theme-name",
- "org.gnome.desktop.interface",
- "cursor-theme"
- },
- {
- "gtk-cursor-theme-size",
- "org.gnome.desktop.interface",
- "cursor-size"
- },
- {
- "gtk-enable-animations",
- "org.gnome.desktop.interface",
- "enable-animations"
- },
- {
- "gtk-im-module",
- "org.gnome.desktop.interface",
- "gtk-im-module"
- },
- {
- "gtk-recent-files-max-age",
- "org.gnome.desktop.privacy",
- "recent-files-max-age"
- },
- {
- "gtk-sound-theme-name",
- "org.gnome.desktop.sound",
- "theme-name"
- },
- {
- "gtk-enable-input-feedback-sounds",
- "org.gnome.desktop.sound",
- "input-feedback-sounds"
- },
- {
- "gtk-enable-event-sounds",
- "org.gnome.desktop.sound",
- "event-sounds"
- },
- {
- "gtk-shell-shows-desktop",
- "org.gnome.desktop.background",
- "show-desktop-icons"
- },
- {
- "gtk-decoration-layout",
- "org.gnome.desktop.wm.preferences",
- "button-layout"
- },
- {
- "gtk-titlebar-double-click",
- "org.gnome.desktop.wm.preferences",
- "action-double-click-titlebar"
- },
- {
- "gtk-titlebar-middle-click",
- "org.gnome.desktop.wm.preferences",
- "action-middle-click-titlebar"
- },
- {
- "gtk-titlebar-right-click",
- "org.gnome.desktop.wm.preferences",
- "action-right-click-titlebar"
- },
- {
- "gtk-enable-primary-paste",
- "org.gnome.desktop.interface",
- "gtk-enable-primary-paste"
- },
- {
- "gtk-recent-files-enabled",
- "org.gnome.desktop.privacy",
- "remember-recent-files"
- },
- {
- "gtk-keynav-use-caret",
- "org.gnome.desktop.a11y",
- "always-show-text-caret"
- },
- { NULL }
-};
-
-static guint
-get_scaling_factor (GdkMirScreen *screen)
-{
- GVariant *variant;
- guint scaling_factor;
-
- variant = read_setting (screen, "org.gnome.desktop.interface", "scaling-factor");
-
- if (!variant)
- {
- g_warning ("no scaling factor: org.gnome.desktop.interface.scaling-factor");
- variant = g_variant_ref_sink (g_variant_new_uint32 (0));
- }
-
- scaling_factor = g_variant_get_uint32 (variant);
- g_variant_unref (variant);
-
- if (scaling_factor)
- return scaling_factor;
-
- scaling_factor = 1;
-
- /* TODO: scaling_factor = 2 if HiDPI >= 2 * 96 */
-
- return scaling_factor;
-}
-
-static void
-update_setting (GdkMirScreen *screen,
- const gchar *name)
-{
- GVariant *variant;
- GVariant *antialiasing_variant;
- gboolean gtk_xft_antialias;
- gboolean gtk_xft_hinting;
- gdouble text_scaling_factor;
- gint cursor_size;
- gint i;
-
- if (!g_strcmp0 (name, "gtk-modules"))
- {
- /* TODO: X-GTK-Module-Enabled-Schema, X-GTK-Module-Enabled-Key */
- /* TODO: org.gnome.settings-daemon.plugins.xsettings.enabled-gtk-modules */
- /* TODO: org.gnome.settings-daemon.plugins.xsettings.disabled-gtk-modules */
- return;
- }
- else
- {
- for (i = 0; SETTINGS_MAP[i].name; i++)
- if (!g_strcmp0 (name, SETTINGS_MAP[i].name))
- break;
-
- if (!SETTINGS_MAP[i].name)
- return;
-
- variant = read_setting (screen, SETTINGS_MAP[i].schema_id, SETTINGS_MAP[i].key);
-
- if (!variant)
- {
- g_warning ("no setting for %s: %s.%s", SETTINGS_MAP[i].name, SETTINGS_MAP[i].schema_id, SETTINGS_MAP[i].key);
- return;
- }
- }
-
- if (!g_strcmp0 (name, "gtk-xft-antialias"))
- {
- gtk_xft_antialias = g_strcmp0 (g_variant_get_string (variant, NULL), "none");
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_int32 (gtk_xft_antialias ? 1 : 0));
- }
- else if (!g_strcmp0 (name, "gtk-xft-hinting"))
- {
- gtk_xft_hinting = g_strcmp0 (g_variant_get_string (variant, NULL), "none");
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_int32 (gtk_xft_hinting ? 1 : 0));
- }
- else if (!g_strcmp0 (name, "gtk-xft-hintstyle"))
- {
- if (!g_strcmp0 (g_variant_get_string (variant, NULL), "none"))
- {
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_string ("hintnone"));
- }
- else if (!g_strcmp0 (g_variant_get_string (variant, NULL), "slight"))
- {
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_string ("hintslight"));
- }
- else if (!g_strcmp0 (g_variant_get_string (variant, NULL), "medium"))
- {
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_string ("hintmedium"));
- }
- else if (!g_strcmp0 (g_variant_get_string (variant, NULL), "full"))
- {
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_string ("hintfull"));
- }
- else
- {
- g_warning ("unknown org.gnome.settings-daemon.plugins.xsettings.hinting value: %s", g_variant_get_string (variant, NULL));
- g_variant_unref (variant);
- return;
- }
- }
- else if (!g_strcmp0 (name, "gtk-xft-rgba"))
- {
- antialiasing_variant = read_setting (screen, "org.gnome.settings-daemon.plugins.xsettings", "antialiasing");
-
- if (g_strcmp0 (g_variant_get_string (antialiasing_variant, NULL), "rgba"))
- {
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_string ("none"));
- }
- else if (g_strcmp0 (g_variant_get_string (variant, NULL), "rgba"))
- {
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_string ("rgb"));
- }
-
- g_variant_unref (antialiasing_variant);
- }
- else if (!g_strcmp0 (name, "gtk-xft-dpi"))
- {
- text_scaling_factor = g_variant_get_double (variant);
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_int32 (1024 * get_scaling_factor (screen) * text_scaling_factor + 0.5));
- }
- else if (!g_strcmp0 (name, "gtk-cursor-theme-size"))
- {
- cursor_size = g_variant_get_int32 (variant);
- g_variant_unref (variant);
- variant = g_variant_ref_sink (g_variant_new_int32 (get_scaling_factor (screen) * cursor_size));
- }
- else if (!g_strcmp0 (name, "gtk-enable-animations"))
- {
- /* TODO: disable under vnc/vino/llvmpipe */
- }
-
- change_setting (screen, name, variant);
- g_variant_unref (variant);
-}
-
-static void
-setting_changed (GSettings *settings,
- const gchar *key,
- GdkMirScreen *screen)
-{
- gchar *schema_id;
- gint i;
-
- g_object_get (settings, "schema-id", &schema_id, NULL);
-
- for (i = 0; SETTINGS_MAP[i].name; i++)
- if (!g_strcmp0 (schema_id, SETTINGS_MAP[i].schema_id) && !g_strcmp0 (key, SETTINGS_MAP[i].key))
- update_setting (screen, SETTINGS_MAP[i].name);
-
- if (!g_strcmp0 (schema_id, "org.gnome.settings-daemon.plugins.xsettings"))
- {
- if (!g_strcmp0 (key, "enabled-gtk-modules"))
- update_setting (screen, "gtk-modules");
- else if (!g_strcmp0 (key, "disabled-gtk-modules"))
- update_setting (screen, "gtk-modules");
- else if (!g_strcmp0 (key, "antialiasing"))
- update_setting (screen, "rgba-order");
- }
- else if (!g_strcmp0 (schema_id, "org.gnome.desktop.interface"))
- {
- if (!g_strcmp0 (key, "scaling-factor"))
- {
- update_setting (screen, "gtk-xft-dpi");
- update_setting (screen, "gtk-cursor-theme-size");
- }
- }
-
- g_free (schema_id);
-}
-
-static const gchar * const KNOWN_SETTINGS[] =
-{
- "gtk-double-click-time",
- "gtk-double-click-distance",
- "gtk-cursor-blink",
- "gtk-cursor-blink-time",
- "gtk-cursor-blink-timeout",
- "gtk-split-cursor",
- "gtk-theme-name",
- "gtk-icon-theme-name",
- "gtk-key-theme-name",
- "gtk-dnd-drag-threshold",
- "gtk-font-name",
- "gtk-modules",
- "gtk-xft-antialias",
- "gtk-xft-hinting",
- "gtk-xft-hintstyle",
- "gtk-xft-rgba",
- "gtk-xft-dpi",
- "gtk-cursor-theme-name",
- "gtk-cursor-theme-size",
- "gtk-alternative-button-order",
- "gtk-alternative-sort-arrows",
- "gtk-enable-animations",
- "gtk-error-bell",
- "gtk-print-backends",
- "gtk-print-preview-command",
- "gtk-enable-accels",
- "gtk-im-module",
- "gtk-recent-files-max-age",
- "gtk-fontconfig-timestamp",
- "gtk-sound-theme-name",
- "gtk-enable-input-feedback-sounds",
- "gtk-enable-event-sounds",
- "gtk-primary-button-warps-slider",
- "gtk-application-prefer-dark-theme",
- "gtk-entry-select-on-focus",
- "gtk-entry-password-hint-timeout",
- "gtk-label-select-on-focus",
- "gtk-shell-shows-app-menu",
- "gtk-shell-shows-menubar",
- "gtk-shell-shows-desktop",
- "gtk-decoration-layout",
- "gtk-titlebar-double-click",
- "gtk-titlebar-middle-click",
- "gtk-titlebar-right-click",
- "gtk-dialogs-use-header",
- "gtk-enable-primary-paste",
- "gtk-recent-files-enabled",
- "gtk-long-press-time",
- "gtk-keynav-use-caret",
- NULL
-};
-
-gboolean
-gdk_mir_screen_get_setting (GdkScreen *screen,
- const gchar *name,
- GValue *value)
-{
- GdkMirScreen *mir_screen;
- GVariant *variant;
-
- mir_screen = GDK_MIR_SCREEN (screen);
- variant = g_hash_table_lookup (mir_screen->current_settings, name);
-
- if (!variant)
- update_setting (mir_screen, name);
-
- variant = g_hash_table_lookup (mir_screen->current_settings, name);
-
- if (!variant)
- {
- if (!g_strv_contains (KNOWN_SETTINGS, name))
- g_warning ("unknown setting: %s", name);
-
- return FALSE;
- }
-
- g_dbus_gvariant_to_gvalue (variant, value);
- return TRUE;
-}
-
-static void
-gdk_mir_screen_init (GdkMirScreen *screen)
-{
- screen->settings_objects = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
- screen->current_settings = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
-}
-
-static void
-gdk_mir_screen_class_init (GdkMirScreenClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GdkScreenClass *screen_class = GDK_SCREEN_CLASS (klass);
-
- object_class->dispose = gdk_mir_screen_dispose;
- object_class->finalize = gdk_mir_screen_finalize;
-
- screen_class->get_display = gdk_mir_screen_get_display;
- screen_class->get_root_window = gdk_mir_screen_get_root_window;
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#include "gdkinternals.h"
-
-#include "gdkmir.h"
-
-#define GDK_MIR_WINDOW(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_MIR, GdkMirWindow))
-#define GDK_MIR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_MIR, GdkMirWindowClass))
-#define GDK_IS_WINDOW_MIR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_MIR))
-#define GDK_MIR_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_MIR, GdkMirWindowClass))
-
-typedef struct _GdkMirWindow GdkMirWindow;
-typedef struct _GdkMirWindowClass GdkMirWindowClass;
-
-struct _GdkMirWindow
-{
- GdkWindow parent_instance;
-};
-
-struct _GdkMirWindowClass
-{
- GdkWindowClass parent_class;
-};
-
-G_DEFINE_TYPE (GdkMirWindow, gdk_mir_window, GDK_TYPE_WINDOW)
-
-static void
-gdk_mir_window_init (GdkMirWindow *impl)
-{
-}
-
-static void
-gdk_mir_window_class_init (GdkMirWindowClass *klass)
-{
-}
+++ /dev/null
-/*
- * Copyright © 2014 Canonical Ltd
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <inttypes.h>
-#include <math.h>
-
-#include "config.h"
-
-#include "gdk.h"
-#include "gdkmir.h"
-#include "gdkmir-private.h"
-
-#include "gdkwindowimpl.h"
-#include "gdkinternals.h"
-#include "gdkintl.h"
-#include "gdkdisplayprivate.h"
-#include "gdkdeviceprivate.h"
-
-#define GDK_MIR_WINDOW_IMPL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_IMPL_MIR, GdkMirWindowImplClass))
-#define GDK_IS_WINDOW_IMPL_MIR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_IMPL_MIR))
-#define GDK_MIR_WINDOW_IMPL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_IMPL_MIR, GdkMirWindowImplClass))
-
-#define MAX_EGL_ATTRS 30
-
-typedef struct _GdkMirWindowImplClass GdkMirWindowImplClass;
-
-struct _GdkMirWindowImpl
-{
- GdkWindowImpl parent_instance;
-
- /* Window we are temporary for */
- GdkWindow *transient_for;
- gint transient_x;
- gint transient_y;
-
- /* gdk_window_move_to_rect */
- gboolean has_rect;
- GdkRectangle rect;
- MirRectangle mir_rect;
- MirPlacementGravity rect_anchor;
- MirPlacementGravity window_anchor;
- MirPlacementHints anchor_hints;
- gint rect_anchor_dx;
- gint rect_anchor_dy;
-
- /* Desired window attributes */
- GdkWindowTypeHint type_hint;
- MirWindowState window_state;
- gboolean modal;
-
- /* Current button state for checking which buttons are being pressed / released */
- gdouble x;
- gdouble y;
- guint button_state;
-
- GdkDisplay *display;
-
- /* Window being rendered to (only exists when visible) */
- MirWindow *mir_window;
- MirBufferStream *buffer_stream;
- MirBufferUsage buffer_usage;
-
- /* Cairo context for current frame */
- cairo_surface_t *cairo_surface;
-
- gchar *title;
-
- GdkGeometry geometry_hints;
- GdkWindowHints geometry_mask;
-
- /* Egl surface for the current mir window */
- EGLSurface egl_surface;
-
- /* Dummy MIR and EGL surfaces */
- EGLSurface dummy_egl_surface;
-
- /* TRUE if the window can be seen */
- gboolean visible;
-
- /* TRUE if cursor is inside this window */
- gboolean cursor_inside;
-
- gboolean pending_spec_update;
- gint output_scale;
-};
-
-struct _GdkMirWindowImplClass
-{
- GdkWindowImplClass parent_class;
-};
-
-G_DEFINE_TYPE (GdkMirWindowImpl, gdk_mir_window_impl, GDK_TYPE_WINDOW_IMPL)
-
-static cairo_surface_t *gdk_mir_window_impl_ref_cairo_surface (GdkWindow *window);
-static void ensure_mir_window (GdkWindow *window);
-
-static gboolean
-type_hint_differs (GdkWindowTypeHint lhs, GdkWindowTypeHint rhs)
-{
- if (lhs == rhs)
- return FALSE;
-
- switch (lhs)
- {
- case GDK_WINDOW_TYPE_HINT_DIALOG:
- case GDK_WINDOW_TYPE_HINT_DOCK:
- return rhs != GDK_WINDOW_TYPE_HINT_DIALOG &&
- rhs != GDK_WINDOW_TYPE_HINT_DOCK;
- case GDK_WINDOW_TYPE_HINT_MENU:
- case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
- case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
- case GDK_WINDOW_TYPE_HINT_TOOLBAR:
- case GDK_WINDOW_TYPE_HINT_COMBO:
- case GDK_WINDOW_TYPE_HINT_DND:
- case GDK_WINDOW_TYPE_HINT_TOOLTIP:
- case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
- return rhs != GDK_WINDOW_TYPE_HINT_MENU &&
- rhs != GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU &&
- rhs != GDK_WINDOW_TYPE_HINT_POPUP_MENU &&
- rhs != GDK_WINDOW_TYPE_HINT_TOOLBAR &&
- rhs != GDK_WINDOW_TYPE_HINT_COMBO &&
- rhs != GDK_WINDOW_TYPE_HINT_DND &&
- rhs != GDK_WINDOW_TYPE_HINT_TOOLTIP &&
- rhs != GDK_WINDOW_TYPE_HINT_NOTIFICATION;
- case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
- case GDK_WINDOW_TYPE_HINT_UTILITY:
- return rhs != GDK_WINDOW_TYPE_HINT_SPLASHSCREEN &&
- rhs != GDK_WINDOW_TYPE_HINT_UTILITY;
- case GDK_WINDOW_TYPE_HINT_NORMAL:
- case GDK_WINDOW_TYPE_HINT_DESKTOP:
- default:
- return rhs != GDK_WINDOW_TYPE_HINT_NORMAL &&
- rhs != GDK_WINDOW_TYPE_HINT_DESKTOP;
- }
-}
-
-static void
-drop_cairo_surface (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy);
-}
-
-static const gchar *
-get_default_title (void)
-{
- const char *title;
-
- title = g_get_application_name ();
- if (!title)
- title = g_get_prgname ();
- if (!title)
- title = "";
-
- return title;
-}
-
-GdkWindowImpl *
-_gdk_mir_window_impl_new (GdkDisplay *display, GdkWindow *window)
-{
- GdkMirWindowImpl *impl = g_object_new (GDK_TYPE_MIR_WINDOW_IMPL, NULL);
-
- impl->display = display;
-
- impl->title = g_strdup (get_default_title ());
-
- impl->pending_spec_update = TRUE;
-
- return (GdkWindowImpl *) impl;
-}
-
-void
-_gdk_mir_window_impl_set_window_state (GdkMirWindowImpl *impl,
- MirWindowState state)
-{
- impl->window_state = state;
-}
-
-void
-_gdk_mir_window_impl_set_window_type (GdkMirWindowImpl *impl,
- MirWindowType type)
-{
-}
-
-void
-_gdk_mir_window_impl_set_cursor_state (GdkMirWindowImpl *impl,
- gdouble x,
- gdouble y,
- gboolean cursor_inside,
- guint button_state)
-{
- impl->x = x;
- impl->y = y;
- impl->cursor_inside = cursor_inside;
- impl->button_state = button_state;
-}
-
-void
-_gdk_mir_window_impl_get_cursor_state (GdkMirWindowImpl *impl,
- gdouble *x,
- gdouble *y,
- gboolean *cursor_inside,
- guint *button_state)
-{
- if (x)
- *x = impl->x;
- if (y)
- *y = impl->y;
- if (cursor_inside)
- *cursor_inside = impl->cursor_inside;
- if (button_state)
- *button_state = impl->button_state;
-}
-
-static void
-gdk_mir_window_impl_init (GdkMirWindowImpl *impl)
-{
- impl->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
- impl->window_state = mir_window_state_unknown;
- impl->output_scale = 1;
-}
-
-static void
-set_window_state (GdkMirWindowImpl *impl,
- MirWindowState state)
-{
- MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
- MirWindowSpec *spec;
-
- if (state == impl->window_state)
- return;
-
- impl->window_state = state;
-
- if (impl->mir_window && !impl->pending_spec_update)
- {
- spec = mir_create_window_spec (connection);
- mir_window_spec_set_state (spec, state);
- mir_window_apply_spec (impl->mir_window, spec);
- mir_window_spec_release (spec);
- }
-}
-
-static void
-event_cb (MirWindow *mir_window,
- const MirEvent *event,
- void *context)
-{
- _gdk_mir_event_source_queue (context, event);
-}
-
-static MirWindowSpec *
-create_window_type_spec (GdkDisplay *display,
- GdkWindow *parent,
- gint x,
- gint y,
- gint width,
- gint height,
- gboolean modal,
- GdkWindowTypeHint type,
- MirBufferUsage buffer_usage)
-{
- MirConnection *connection = gdk_mir_display_get_mir_connection (display);
- MirWindow *parent_mir_window = NULL;
- MirPixelFormat format;
- MirRectangle rect;
- MirWindowSpec *spec;
-
- if (parent && parent->impl)
- {
- ensure_mir_window (parent);
- parent_mir_window = GDK_MIR_WINDOW_IMPL (parent->impl)->mir_window;
- }
-
- if (!parent_mir_window)
- {
- switch (type)
- {
- case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
- case GDK_WINDOW_TYPE_HINT_UTILITY:
- type = GDK_WINDOW_TYPE_HINT_DIALOG;
- break;
- default:
- break;
- }
- }
-
- format = _gdk_mir_display_get_pixel_format (display, buffer_usage);
-
- rect.left = x;
- rect.top = y;
- rect.width = 1;
- rect.height = 1;
-
- switch (type)
- {
- case GDK_WINDOW_TYPE_HINT_DIALOG:
- if (modal)
- spec = mir_create_modal_dialog_window_spec (connection,
- width,
- height,
- parent_mir_window);
- else
- spec = mir_create_dialog_window_spec (connection,
- width,
- height);
- break;
- case GDK_WINDOW_TYPE_HINT_DOCK:
- spec = mir_create_dialog_window_spec (connection,
- width,
- height);
- break;
- case GDK_WINDOW_TYPE_HINT_MENU:
- case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
- case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
- case GDK_WINDOW_TYPE_HINT_TOOLBAR:
- case GDK_WINDOW_TYPE_HINT_COMBO:
- case GDK_WINDOW_TYPE_HINT_DND:
- case GDK_WINDOW_TYPE_HINT_TOOLTIP:
- case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
- spec = mir_create_menu_window_spec (connection,
- width,
- height,
- parent_mir_window,
- &rect,
- 0);
- break;
- case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
- case GDK_WINDOW_TYPE_HINT_UTILITY:
- spec = mir_create_modal_dialog_window_spec (connection,
- width,
- height,
- parent_mir_window);
- break;
- case GDK_WINDOW_TYPE_HINT_NORMAL:
- case GDK_WINDOW_TYPE_HINT_DESKTOP:
- default:
- spec = mir_create_normal_window_spec (connection,
- width,
- height);
- break;
- }
-
- mir_window_spec_set_pixel_format (spec, format);
-
- return spec;
-}
-
-static void
-apply_geometry_hints (MirWindowSpec *spec,
- GdkMirWindowImpl *impl)
-{
- if (impl->geometry_mask & GDK_HINT_RESIZE_INC)
- {
- mir_window_spec_set_width_increment (spec, impl->geometry_hints.width_inc);
- mir_window_spec_set_height_increment (spec, impl->geometry_hints.height_inc);
- }
- if (impl->geometry_mask & GDK_HINT_MIN_SIZE)
- {
- mir_window_spec_set_min_width (spec, impl->geometry_hints.min_width);
- mir_window_spec_set_min_height (spec, impl->geometry_hints.min_height);
- }
- if (impl->geometry_mask & GDK_HINT_MAX_SIZE)
- {
- mir_window_spec_set_max_width (spec, impl->geometry_hints.max_width);
- mir_window_spec_set_max_height (spec, impl->geometry_hints.max_height);
- }
- if (impl->geometry_mask & GDK_HINT_ASPECT)
- {
- mir_window_spec_set_min_aspect_ratio (spec, (guint) 1000 * impl->geometry_hints.min_aspect, 1000);
- mir_window_spec_set_max_aspect_ratio (spec, (guint) 1000 * impl->geometry_hints.max_aspect, 1000);
- }
-}
-
-static MirWindowSpec *
-create_spec (GdkWindow *window,
- GdkMirWindowImpl *impl)
-{
- MirWindowSpec *spec = NULL;
- GdkWindow *parent;
- MirRectangle rect;
-
- spec = create_window_type_spec (impl->display,
- impl->transient_for,
- impl->transient_x,
- impl->transient_y,
- window->width,
- window->height,
- impl->modal,
- impl->type_hint,
- impl->buffer_usage);
-
- mir_window_spec_set_name (spec, impl->title);
- mir_window_spec_set_buffer_usage (spec, impl->buffer_usage);
-
- apply_geometry_hints (spec, impl);
-
- if (impl->has_rect)
- {
- impl->mir_rect.left = impl->rect.x;
- impl->mir_rect.top = impl->rect.y;
- impl->mir_rect.width = impl->rect.width;
- impl->mir_rect.height = impl->rect.height;
-
- parent = impl->transient_for;
-
- while (parent && !gdk_window_has_native (parent))
- {
- impl->mir_rect.left += parent->x;
- impl->mir_rect.top += parent->y;
-
- parent = gdk_window_get_parent (parent);
- }
-
- mir_window_spec_set_placement (spec,
- &impl->mir_rect,
- impl->rect_anchor,
- impl->window_anchor,
- impl->anchor_hints,
- impl->rect_anchor_dx,
- impl->rect_anchor_dy);
- }
- else
- {
- switch (impl->type_hint)
- {
- case GDK_WINDOW_TYPE_HINT_MENU:
- case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
- case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
- case GDK_WINDOW_TYPE_HINT_TOOLBAR:
- case GDK_WINDOW_TYPE_HINT_COMBO:
- case GDK_WINDOW_TYPE_HINT_DND:
- case GDK_WINDOW_TYPE_HINT_TOOLTIP:
- case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
- rect.left = impl->transient_x;
- rect.top = impl->transient_y;
- rect.width = 1;
- rect.height = 1;
-
- mir_window_spec_set_placement (spec,
- &rect,
- mir_placement_gravity_southeast,
- mir_placement_gravity_northwest,
- (mir_placement_hints_flip_x |
- mir_placement_hints_flip_y |
- mir_placement_hints_slide_x |
- mir_placement_hints_slide_y |
- mir_placement_hints_resize_x |
- mir_placement_hints_resize_y),
- -window->shadow_left,
- -window->shadow_top);
-
- break;
- default:
- break;
- }
- }
-
- return spec;
-}
-
-static void
-update_window_spec (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- MirWindowSpec *spec;
-
- if (!impl->mir_window)
- return;
-
- spec = create_spec (window, impl);
-
- mir_window_apply_spec (impl->mir_window, spec);
- mir_window_spec_release (spec);
-
- impl->pending_spec_update = FALSE;
- impl->buffer_stream = mir_window_get_buffer_stream (impl->mir_window);
-}
-
-static GdkDevice *
-get_pointer (GdkWindow *window)
-{
- GdkDisplay *display;
- GdkSeat *seat;
- GdkDevice *pointer;
-
- display = gdk_window_get_display (window);
- seat = gdk_display_get_default_seat (display);
- pointer = gdk_seat_get_pointer (seat);
-
- return pointer;
-}
-
-static void
-send_event (GdkWindow *window, GdkDevice *device, GdkEvent *event)
-{
- GdkDisplay *display;
- GList *node;
-
- display = gdk_window_get_display (window);
- gdk_event_set_device (event, device);
- gdk_event_set_source_device (event, device);
- gdk_event_set_display (event, display);
- event->any.window = g_object_ref (window);
-
- node = _gdk_event_queue_append (display, event);
- _gdk_windowing_got_event (display, node, event, _gdk_display_get_next_serial (display));
-}
-
-static void
-generate_configure_event (GdkWindow *window,
- gint width,
- gint height)
-{
- GdkEvent *event;
-
- event = gdk_event_new (GDK_CONFIGURE);
- event->configure.send_event = FALSE;
- event->configure.width = width;
- event->configure.height = height;
-
- send_event (window, get_pointer (window), event);
-}
-
-static void
-synthesize_resize (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- MirWindowParameters params;
-
- if (!impl->mir_window)
- return;
-
- mir_window_get_parameters (impl->mir_window, ¶ms);
-
- window->width = params.width;
- window->height = params.height;
-
- _gdk_window_update_size (window);
-
- generate_configure_event (window, window->width, window->height);
-}
-
-static void
-maybe_synthesize_resize (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- MirWindowParameters params;
-
- if (!impl->mir_window)
- return;
-
- mir_window_get_parameters (impl->mir_window, ¶ms);
-
- if (params.width != window->width || params.height != window->height)
- {
- window->width = params.width;
- window->height = params.height;
-
- _gdk_window_update_size (window);
-
- generate_configure_event (window, window->width, window->height);
- }
-}
-
-static void
-ensure_mir_window_full (GdkWindow *window,
- MirBufferUsage buffer_usage)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- GdkMirWindowReference *window_ref;
- MirWindowSpec *spec;
-
- if (window->input_only)
- return;
-
- if (impl->mir_window)
- {
- if (impl->pending_spec_update)
- update_window_spec (window);
- return;
- }
-
- /* no destroy notify -- we must leak for now
- * https://bugs.launchpad.net/mir/+bug/1324100
- */
- window_ref = _gdk_mir_event_source_get_window_reference (window);
- impl->buffer_usage = buffer_usage;
-
- spec = create_spec (window, impl);
-
- impl->mir_window = mir_create_window_sync (spec);
-
- mir_window_spec_release (spec);
-
- impl->pending_spec_update = FALSE;
- impl->buffer_stream = mir_window_get_buffer_stream (impl->mir_window);
-
- synthesize_resize (window);
-
- /* FIXME: Ignore some events until shown */
- mir_window_set_event_handler (impl->mir_window, event_cb, window_ref);
-}
-
-static void
-ensure_mir_window (GdkWindow *window)
-{
- ensure_mir_window_full (window,
- window->gl_paint_context ?
- mir_buffer_usage_hardware :
- mir_buffer_usage_software);
-}
-
-static void
-ensure_no_mir_window (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- if (impl->cairo_surface)
- {
- cairo_surface_finish (impl->cairo_surface);
- g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy);
- }
-
- if (window->gl_paint_context)
- {
- GdkDisplay *display = gdk_window_get_display (window);
- EGLDisplay egl_display = _gdk_mir_display_get_egl_display (display);
-
- if (impl->egl_surface)
- {
- eglDestroySurface (egl_display, impl->egl_surface);
- impl->egl_surface = NULL;
- }
-
- if (impl->dummy_egl_surface)
- {
- eglDestroySurface (egl_display, impl->dummy_egl_surface);
- impl->dummy_egl_surface = NULL;
- }
- }
-
- g_clear_pointer (&impl->mir_window, mir_window_release_sync);
-}
-
-static void
-send_buffer (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- /* Send the completed buffer to Mir */
- if (impl->mir_window)
- mir_buffer_stream_swap_buffers_sync (mir_window_get_buffer_stream (impl->mir_window));
-
- /* The Cairo context is no longer valid */
- g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy);
- if (impl->pending_spec_update)
- update_window_spec (window);
-
- impl->pending_spec_update = FALSE;
-
- maybe_synthesize_resize (window);
-}
-
-static cairo_surface_t *
-gdk_mir_window_impl_ref_cairo_surface (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- MirGraphicsRegion region;
- cairo_format_t pixel_format = CAIRO_FORMAT_ARGB32;
- cairo_surface_t *cairo_surface;
-
- if (impl->cairo_surface)
- {
- cairo_surface_reference (impl->cairo_surface);
- return impl->cairo_surface;
- }
-
- ensure_mir_window (window);
-
- if (!impl->mir_window)
- return NULL;
-
- if (window->gl_paint_context)
- {
- cairo_surface = cairo_image_surface_create (pixel_format, window->width, window->height);
- cairo_surface_set_device_scale (cairo_surface, (double) impl->output_scale, (double) impl->output_scale);
- }
- else if (impl->visible)
- {
- mir_buffer_stream_get_graphics_region (mir_window_get_buffer_stream (impl->mir_window), ®ion);
-
- switch (region.pixel_format)
- {
- case mir_pixel_format_abgr_8888:
- g_warning ("pixel format ABGR 8888 not supported, using ARGB 8888");
- pixel_format = CAIRO_FORMAT_ARGB32;
- break;
- case mir_pixel_format_xbgr_8888:
- g_warning ("pixel format XBGR 8888 not supported, using XRGB 8888");
- pixel_format = CAIRO_FORMAT_RGB24;
- break;
- case mir_pixel_format_argb_8888:
- pixel_format = CAIRO_FORMAT_ARGB32;
- break;
- case mir_pixel_format_xrgb_8888:
- pixel_format = CAIRO_FORMAT_RGB24;
- break;
- case mir_pixel_format_bgr_888:
- g_error ("pixel format BGR 888 not supported");
- break;
- case mir_pixel_format_rgb_888:
- g_error ("pixel format RGB 888 not supported");
- break;
- case mir_pixel_format_rgb_565:
- pixel_format = CAIRO_FORMAT_RGB16_565;
- break;
- case mir_pixel_format_rgba_5551:
- g_error ("pixel format RGBA 5551 not supported");
- break;
- case mir_pixel_format_rgba_4444:
- g_error ("pixel format RGBA 4444 not supported");
- break;
- default:
- g_error ("unknown pixel format");
- break;
- }
-
- cairo_surface = cairo_image_surface_create_for_data ((unsigned char *) region.vaddr,
- pixel_format,
- region.width,
- region.height,
- region.stride);
- cairo_surface_set_device_scale (cairo_surface, (double) impl->output_scale, (double) impl->output_scale);
- }
- else
- cairo_surface = cairo_image_surface_create (pixel_format, 0, 0);
-
- impl->cairo_surface = cairo_surface_reference (cairo_surface);
-
- return cairo_surface;
-}
-
-static cairo_surface_t *
-gdk_mir_window_impl_create_similar_image_surface (GdkWindow *window,
- cairo_format_t format,
- int width,
- int height)
-{
- return cairo_image_surface_create (format, width, height);
-}
-
-static void
-gdk_mir_window_impl_finalize (GObject *object)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (object);
-
- g_free (impl->title);
-
- g_clear_pointer (&impl->mir_window, mir_window_release_sync);
- g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy);
-
- G_OBJECT_CLASS (gdk_mir_window_impl_parent_class)->finalize (object);
-}
-
-static void
-gdk_mir_window_impl_show (GdkWindow *window,
- gboolean already_mapped)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- cairo_surface_t *s;
-
- impl->visible = TRUE;
- set_window_state (impl, mir_window_state_restored);
-
- /* Make sure there's a window to see */
- ensure_mir_window (window);
-
- if (!window->gl_paint_context)
- {
- /* Make sure something is rendered and then show first frame */
- s = gdk_mir_window_impl_ref_cairo_surface (window);
- send_buffer (window);
- cairo_surface_destroy (s);
- }
-}
-
-static void
-gdk_mir_window_impl_hide (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- impl->cursor_inside = FALSE;
- impl->visible = FALSE;
-
- set_window_state (impl, mir_window_state_hidden);
-}
-
-static void
-gdk_mir_window_impl_withdraw (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- impl->cursor_inside = FALSE;
- impl->visible = FALSE;
-
- set_window_state (impl, mir_window_state_hidden);
-}
-
-static void
-gdk_mir_window_impl_raise (GdkWindow *window)
-{
- /* We don't support client window stacking */
-}
-
-static void
-gdk_mir_window_impl_lower (GdkWindow *window)
-{
- /* We don't support client window stacking */
-}
-
-static void
-gdk_mir_window_impl_restack_toplevel (GdkWindow *window,
- GdkWindow *sibling,
- gboolean above)
-{
- /* We don't support client window stacking */
-}
-
-static void
-gdk_mir_window_impl_move_resize (GdkWindow *window,
- gboolean with_move,
- gint x,
- gint y,
- gint width,
- gint height)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- /* If resize requested then rebuild window */
- if (width >= 0 && (window->width != width || window->height != height))
- {
- /* We accept any resize */
- window->width = width;
- window->height = height;
- impl->pending_spec_update = TRUE;
- }
-
- /* Transient windows can move wherever they want */
- if (with_move)
- {
- if (impl->has_rect || x != impl->transient_x || y != impl->transient_y)
- {
- impl->has_rect = FALSE;
- impl->transient_x = x;
- impl->transient_y = y;
- if (!impl->pending_spec_update && impl->mir_window)
- update_window_spec (window);
- }
- }
-}
-
-static MirPlacementGravity
-get_mir_placement_gravity (GdkGravity gravity)
-{
- switch (gravity)
- {
- case GDK_GRAVITY_STATIC:
- case GDK_GRAVITY_NORTH_WEST:
- return mir_placement_gravity_northwest;
- case GDK_GRAVITY_NORTH:
- return mir_placement_gravity_north;
- case GDK_GRAVITY_NORTH_EAST:
- return mir_placement_gravity_northeast;
- case GDK_GRAVITY_WEST:
- return mir_placement_gravity_west;
- case GDK_GRAVITY_CENTER:
- return mir_placement_gravity_center;
- case GDK_GRAVITY_EAST:
- return mir_placement_gravity_east;
- case GDK_GRAVITY_SOUTH_WEST:
- return mir_placement_gravity_southwest;
- case GDK_GRAVITY_SOUTH:
- return mir_placement_gravity_south;
- case GDK_GRAVITY_SOUTH_EAST:
- return mir_placement_gravity_southeast;
- }
-
- g_warn_if_reached ();
-
- return mir_placement_gravity_center;
-}
-
-static MirPlacementHints
-get_mir_placement_hints (GdkAnchorHints hints)
-{
- MirPlacementHints mir_hints = 0;
-
- if (hints & GDK_ANCHOR_FLIP_X)
- mir_hints |= mir_placement_hints_flip_x;
-
- if (hints & GDK_ANCHOR_FLIP_Y)
- mir_hints |= mir_placement_hints_flip_y;
-
- if (hints & GDK_ANCHOR_SLIDE_X)
- mir_hints |= mir_placement_hints_slide_x;
-
- if (hints & GDK_ANCHOR_SLIDE_Y)
- mir_hints |= mir_placement_hints_slide_y;
-
- if (hints & GDK_ANCHOR_RESIZE_X)
- mir_hints |= mir_placement_hints_resize_x;
-
- if (hints & GDK_ANCHOR_RESIZE_Y)
- mir_hints |= mir_placement_hints_resize_y;
-
- return mir_hints;
-}
-
-static gint
-get_window_shadow_dx (GdkWindow *window,
- GdkGravity window_anchor)
-{
- switch (window_anchor)
- {
- case GDK_GRAVITY_STATIC:
- case GDK_GRAVITY_NORTH_WEST:
- case GDK_GRAVITY_WEST:
- case GDK_GRAVITY_SOUTH_WEST:
- return -window->shadow_left;
-
- case GDK_GRAVITY_NORTH:
- case GDK_GRAVITY_CENTER:
- case GDK_GRAVITY_SOUTH:
- return (window->shadow_right - window->shadow_left) / 2;
-
- case GDK_GRAVITY_NORTH_EAST:
- case GDK_GRAVITY_EAST:
- case GDK_GRAVITY_SOUTH_EAST:
- return window->shadow_right;
- }
-
- g_warn_if_reached ();
-
- return 0;
-}
-
-static gint
-get_window_shadow_dy (GdkWindow *window,
- GdkGravity window_anchor)
-{
- switch (window_anchor)
- {
- case GDK_GRAVITY_STATIC:
- case GDK_GRAVITY_NORTH_WEST:
- case GDK_GRAVITY_NORTH:
- case GDK_GRAVITY_NORTH_EAST:
- return -window->shadow_top;
-
- case GDK_GRAVITY_WEST:
- case GDK_GRAVITY_CENTER:
- case GDK_GRAVITY_EAST:
- return (window->shadow_bottom - window->shadow_top) / 2;
-
- case GDK_GRAVITY_SOUTH_WEST:
- case GDK_GRAVITY_SOUTH:
- case GDK_GRAVITY_SOUTH_EAST:
- return window->shadow_bottom;
- }
-
- g_warn_if_reached ();
-
- return 0;
-}
-
-static void
-gdk_mir_window_impl_move_to_rect (GdkWindow *window,
- const GdkRectangle *rect,
- GdkGravity rect_anchor,
- GdkGravity window_anchor,
- GdkAnchorHints anchor_hints,
- gint rect_anchor_dx,
- gint rect_anchor_dy)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- impl->has_rect = TRUE;
- impl->rect = *rect;
- impl->rect_anchor = get_mir_placement_gravity (rect_anchor);
- impl->window_anchor = get_mir_placement_gravity (window_anchor);
- impl->anchor_hints = get_mir_placement_hints (anchor_hints);
- impl->rect_anchor_dx = rect_anchor_dx + get_window_shadow_dx (window, window_anchor);
- impl->rect_anchor_dy = rect_anchor_dy + get_window_shadow_dy (window, window_anchor);
-
- if (impl->mir_window && !impl->pending_spec_update)
- update_window_spec (window);
-}
-
-static gint
-get_mir_placement_gravity_x (MirPlacementGravity gravity)
-{
- switch (gravity)
- {
- case mir_placement_gravity_west:
- case mir_placement_gravity_northwest:
- case mir_placement_gravity_southwest:
- return 0;
-
- case mir_placement_gravity_center:
- case mir_placement_gravity_north:
- case mir_placement_gravity_south:
- return 1;
-
- case mir_placement_gravity_east:
- case mir_placement_gravity_northeast:
- case mir_placement_gravity_southeast:
- return 2;
- }
-
- g_warn_if_reached ();
-
- return 1;
-}
-
-static gint
-get_mir_placement_gravity_y (MirPlacementGravity gravity)
-{
- switch (gravity)
- {
- case mir_placement_gravity_north:
- case mir_placement_gravity_northwest:
- case mir_placement_gravity_northeast:
- return 0;
-
- case mir_placement_gravity_center:
- case mir_placement_gravity_west:
- case mir_placement_gravity_east:
- return 1;
-
- case mir_placement_gravity_south:
- case mir_placement_gravity_southwest:
- case mir_placement_gravity_southeast:
- return 2;
- }
-
- g_warn_if_reached ();
-
- return 1;
-}
-
-static GdkRectangle
-get_unflipped_rect (const GdkRectangle *rect,
- gint width,
- gint height,
- MirPlacementGravity rect_anchor,
- MirPlacementGravity window_anchor,
- gint rect_anchor_dx,
- gint rect_anchor_dy)
-{
- GdkRectangle unflipped_rect;
-
- unflipped_rect.x = rect->x;
- unflipped_rect.x += rect->width * get_mir_placement_gravity_x (rect_anchor) / 2;
- unflipped_rect.x -= width * get_mir_placement_gravity_x (window_anchor) / 2;
- unflipped_rect.x += rect_anchor_dx;
- unflipped_rect.y = rect->y;
- unflipped_rect.y += rect->height * get_mir_placement_gravity_y (rect_anchor) / 2;
- unflipped_rect.y -= height * get_mir_placement_gravity_y (window_anchor) / 2;
- unflipped_rect.y += rect_anchor_dy;
- unflipped_rect.width = width;
- unflipped_rect.height = height;
-
- return unflipped_rect;
-}
-
-static MirPlacementGravity
-get_opposite_mir_placement_gravity (MirPlacementGravity gravity)
-{
- switch (gravity)
- {
- case mir_placement_gravity_center:
- return mir_placement_gravity_center;
- case mir_placement_gravity_west:
- return mir_placement_gravity_east;
- case mir_placement_gravity_east:
- return mir_placement_gravity_west;
- case mir_placement_gravity_north:
- return mir_placement_gravity_south;
- case mir_placement_gravity_south:
- return mir_placement_gravity_north;
- case mir_placement_gravity_northwest:
- return mir_placement_gravity_southeast;
- case mir_placement_gravity_northeast:
- return mir_placement_gravity_southwest;
- case mir_placement_gravity_southwest:
- return mir_placement_gravity_northeast;
- case mir_placement_gravity_southeast:
- return mir_placement_gravity_northwest;
- }
-
- g_warn_if_reached ();
-
- return gravity;
-}
-
-static gint
-get_anchor_x (const GdkRectangle *rect,
- MirPlacementGravity anchor)
-{
- return rect->x + rect->width * get_mir_placement_gravity_x (anchor) / 2;
-}
-
-static gint
-get_anchor_y (const GdkRectangle *rect,
- MirPlacementGravity anchor)
-{
- return rect->y + rect->height * get_mir_placement_gravity_y (anchor) / 2;
-}
-
-void
-_gdk_mir_window_set_final_rect (GdkWindow *window,
- MirRectangle rect)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- GdkRectangle best_rect;
- GdkRectangle worst_rect;
- GdkRectangle flipped_rect;
- GdkRectangle final_rect;
- gboolean flipped_x = FALSE;
- gboolean flipped_y = FALSE;
- gint test_position;
- gint final_position;
- gint unflipped_offset;
- gint flipped_offset;
-
- if (!impl->has_rect)
- return;
-
- best_rect = get_unflipped_rect (&impl->rect,
- window->width,
- window->height,
- impl->rect_anchor,
- impl->window_anchor,
- impl->rect_anchor_dx,
- impl->rect_anchor_dy);
-
- worst_rect = get_unflipped_rect (&impl->rect,
- window->width,
- window->height,
- get_opposite_mir_placement_gravity (impl->rect_anchor),
- get_opposite_mir_placement_gravity (impl->window_anchor),
- -impl->rect_anchor_dx,
- -impl->rect_anchor_dy);
-
- flipped_rect.x = best_rect.x;
- flipped_rect.y = best_rect.y;
- flipped_rect.width = window->width;
- flipped_rect.height = window->height;
-
- final_rect.x = rect.left - (impl->mir_rect.left - impl->rect.x);
- final_rect.y = rect.top - (impl->mir_rect.top - impl->rect.y);
- final_rect.width = rect.width;
- final_rect.height = rect.height;
-
- if (impl->anchor_hints & mir_placement_hints_flip_x)
- {
- test_position = get_anchor_x (&best_rect, impl->window_anchor);
- final_position = get_anchor_x (&final_rect, impl->window_anchor);
- unflipped_offset = final_position - test_position;
-
- test_position = get_anchor_x (&worst_rect, get_opposite_mir_placement_gravity (impl->window_anchor));
- final_position = get_anchor_x (&final_rect, get_opposite_mir_placement_gravity (impl->window_anchor));
- flipped_offset = final_position - test_position;
-
- if (ABS (flipped_offset) < ABS (unflipped_offset))
- {
- flipped_rect.x = worst_rect.x;
- flipped_x = TRUE;
- }
- }
-
- if (impl->anchor_hints & mir_placement_hints_flip_y)
- {
- test_position = get_anchor_y (&best_rect, impl->window_anchor);
- final_position = get_anchor_y (&final_rect, impl->window_anchor);
- unflipped_offset = final_position - test_position;
-
- test_position = get_anchor_y (&worst_rect, get_opposite_mir_placement_gravity (impl->window_anchor));
- final_position = get_anchor_y (&final_rect, get_opposite_mir_placement_gravity (impl->window_anchor));
- flipped_offset = final_position - test_position;
-
- if (ABS (flipped_offset) < ABS (unflipped_offset))
- {
- flipped_rect.y = worst_rect.y;
- flipped_y = TRUE;
- }
- }
-
- g_signal_emit_by_name (window,
- "moved-to-rect",
- &flipped_rect,
- &final_rect,
- flipped_x,
- flipped_y);
-}
-
-static GdkEventMask
-gdk_mir_window_impl_get_events (GdkWindow *window)
-{
- return window->event_mask;
-}
-
-static void
-gdk_mir_window_impl_set_events (GdkWindow *window,
- GdkEventMask event_mask)
-{
- /* We send all events and let GDK decide */
-}
-
-static void
-gdk_mir_window_impl_get_geometry (GdkWindow *window,
- gint *x,
- gint *y,
- gint *width,
- gint *height)
-{
- if (x)
- *x = 0; // FIXME
- if (y)
- *y = 0; // FIXME
- if (width)
- *width = window->width;
- if (height)
- *height = window->height;
-}
-
-static void
-gdk_mir_window_impl_get_root_coords (GdkWindow *window,
- gint x,
- gint y,
- gint *root_x,
- gint *root_y)
-{
- if (root_x)
- *root_x = x; // FIXME
- if (root_y)
- *root_y = y; // FIXME
-}
-
-static gboolean
-gdk_mir_window_impl_get_device_state (GdkWindow *window,
- GdkDevice *device,
- gdouble *x,
- gdouble *y,
- GdkModifierType *mask)
-{
- GdkWindow *child;
-
- _gdk_device_query_state (device, window, &child, NULL, NULL, x, y, mask);
-
- return child != NULL;
-}
-
-static gboolean
-gdk_mir_window_impl_begin_paint (GdkWindow *window)
-{
- /* Indicate we are ready to be drawn onto directly? */
- return FALSE;
-}
-
-static void
-gdk_mir_window_impl_end_paint (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- if (impl->visible)
- send_buffer (window);
-}
-
-static void
-gdk_mir_window_impl_shape_combine_region (GdkWindow *window,
- const cairo_region_t *shape_region,
- gint offset_x,
- gint offset_y)
-{
-}
-
-static void
-gdk_mir_window_impl_input_shape_combine_region (GdkWindow *window,
- const cairo_region_t *shape_region,
- gint offset_x,
- gint offset_y)
-{
-}
-
-static void
-gdk_mir_window_impl_destroy (GdkWindow *window,
- gboolean recursing,
- gboolean foreign_destroy)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- impl->visible = FALSE;
- ensure_no_mir_window (window);
-}
-
-static void
-gdk_mir_window_impl_focus (GdkWindow *window,
- guint32 timestamp)
-{
-}
-
-static void
-gdk_mir_window_impl_set_type_hint (GdkWindow *window,
- GdkWindowTypeHint hint)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- if (type_hint_differs (hint, impl->type_hint))
- {
- impl->type_hint = hint;
-
- if (impl->mir_window && !impl->pending_spec_update)
- update_window_spec (window);
- }
-}
-
-static GdkWindowTypeHint
-gdk_mir_window_impl_get_type_hint (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- return impl->type_hint;
-}
-
-void
-gdk_mir_window_impl_set_modal_hint (GdkWindow *window,
- gboolean modal)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- if (modal != impl->modal)
- {
- impl->modal = modal;
-
- if (impl->mir_window && !impl->pending_spec_update)
- update_window_spec (window);
- }
-}
-
-static void
-gdk_mir_window_impl_set_skip_taskbar_hint (GdkWindow *window,
- gboolean skips_taskbar)
-{
-}
-
-static void
-gdk_mir_window_impl_set_skip_pager_hint (GdkWindow *window,
- gboolean skips_pager)
-{
-}
-
-static void
-gdk_mir_window_impl_set_urgency_hint (GdkWindow *window,
- gboolean urgent)
-{
-}
-
-static void
-gdk_mir_window_impl_set_geometry_hints (GdkWindow *window,
- const GdkGeometry *geometry,
- GdkWindowHints geom_mask)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
- MirWindowSpec *spec;
-
- impl->geometry_hints = *geometry;
- impl->geometry_mask = geom_mask;
-
- if (impl->mir_window && !impl->pending_spec_update)
- {
- spec = mir_create_window_spec (connection);
- apply_geometry_hints (spec, impl);
- mir_window_apply_spec (impl->mir_window, spec);
- mir_window_spec_release (spec);
- }
-}
-
-static void
-gdk_mir_window_impl_set_title (GdkWindow *window,
- const gchar *title)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
- MirWindowSpec *spec;
-
- g_free (impl->title);
- impl->title = g_strdup (title);
-
- if (impl->mir_window && !impl->pending_spec_update)
- {
- spec = mir_create_window_spec (connection);
- mir_window_spec_set_name (spec, impl->title);
- mir_window_apply_spec (impl->mir_window, spec);
- mir_window_spec_release (spec);
- }
-}
-
-static void
-gdk_mir_window_impl_set_role (GdkWindow *window,
- const gchar *role)
-{
-}
-
-static void
-gdk_mir_window_impl_set_startup_id (GdkWindow *window,
- const gchar *startup_id)
-{
-}
-
-static void
-gdk_mir_window_impl_set_transient_for (GdkWindow *window,
- GdkWindow *parent)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- if (impl->transient_for == parent)
- return;
-
- /* Link this window to the parent */
- impl->transient_for = parent;
-
- if (impl->mir_window && !impl->pending_spec_update)
- update_window_spec (window);
-}
-
-static void
-gdk_mir_window_impl_get_frame_extents (GdkWindow *window,
- GdkRectangle *rect)
-{
-}
-
-static void
-gdk_mir_window_impl_set_accept_focus (GdkWindow *window,
- gboolean accept_focus)
-{
- /* Mir clients cannot control focus */
-}
-
-static void
-gdk_mir_window_impl_set_focus_on_map (GdkWindow *window,
- gboolean focus_on_map)
-{
- /* Mir clients cannot control focus */
-}
-
-static void
-gdk_mir_window_impl_set_icon_list (GdkWindow *window,
- GList *surface)
-{
- // ??
-}
-
-static void
-gdk_mir_window_impl_set_icon_name (GdkWindow *window,
- const gchar *name)
-{
-}
-
-static void
-gdk_mir_window_impl_iconify (GdkWindow *window)
-{
- /* We don't support iconification */
-}
-
-static void
-gdk_mir_window_impl_deiconify (GdkWindow *window)
-{
- /* We don't support iconification */
-}
-
-static void
-gdk_mir_window_impl_stick (GdkWindow *window)
-{
- /* We do not support stick/unstick in Mir */
-}
-
-static void
-gdk_mir_window_impl_unstick (GdkWindow *window)
-{
- /* We do not support stick/unstick in Mir */
-}
-
-static void
-gdk_mir_window_impl_maximize (GdkWindow *window)
-{
- set_window_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_window_state_maximized);
-}
-
-static void
-gdk_mir_window_impl_unmaximize (GdkWindow *window)
-{
- set_window_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_window_state_restored);
-}
-
-static void
-gdk_mir_window_impl_fullscreen (GdkWindow *window)
-{
- set_window_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_window_state_fullscreen);
-}
-
-static void
-gdk_mir_window_impl_apply_fullscreen_mode (GdkWindow *window)
-{
-}
-
-static void
-gdk_mir_window_impl_unfullscreen (GdkWindow *window)
-{
- set_window_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_window_state_restored);
-}
-
-static void
-gdk_mir_window_impl_set_keep_above (GdkWindow *window,
- gboolean setting)
-{
- /* We do not support keep above/below in Mir */
-}
-
-static void
-gdk_mir_window_impl_set_keep_below (GdkWindow *window,
- gboolean setting)
-{
- /* We do not support keep above/below in Mir */
-}
-
-static GdkWindow *
-gdk_mir_window_impl_get_group (GdkWindow *window)
-{
- return NULL;
-}
-
-static void
-gdk_mir_window_impl_set_group (GdkWindow *window,
- GdkWindow *leader)
-{
-}
-
-static void
-gdk_mir_window_impl_set_decorations (GdkWindow *window,
- GdkWMDecoration decorations)
-{
-}
-
-static gboolean
-gdk_mir_window_impl_get_decorations (GdkWindow *window,
- GdkWMDecoration *decorations)
-{
- return FALSE;
-}
-
-static void
-gdk_mir_window_impl_set_functions (GdkWindow *window,
- GdkWMFunction functions)
-{
-}
-
-static void
-gdk_mir_window_impl_begin_resize_drag (GdkWindow *window,
- GdkWindowEdge edge,
- GdkDevice *device,
- gint button,
- gint root_x,
- gint root_y,
- guint32 timestamp)
-{
-}
-
-static void
-gdk_mir_window_impl_begin_move_drag (GdkWindow *window,
- GdkDevice *device,
- gint button,
- gint root_x,
- gint root_y,
- guint32 timestamp)
-{
-}
-
-static void
-gdk_mir_window_impl_enable_synchronized_configure (GdkWindow *window)
-{
-}
-
-static void
-gdk_mir_window_impl_configure_finished (GdkWindow *window)
-{
-}
-
-static void
-gdk_mir_window_impl_set_opacity (GdkWindow *window,
- gdouble opacity)
-{
- // FIXME
-}
-
-static void
-gdk_mir_window_impl_destroy_notify (GdkWindow *window)
-{
-}
-
-static void
-gdk_mir_window_impl_register_dnd (GdkWindow *window)
-{
-}
-
-static GdkDragContext *
-gdk_mir_window_impl_drag_begin (GdkWindow *window,
- GdkDevice *device,
- GList *targets,
- gint x_root,
- gint y_root)
-{
- return NULL;
-}
-
-static void
-gdk_mir_window_impl_process_updates_recurse (GdkWindow *window,
- cairo_region_t *region)
-{
- cairo_rectangle_int_t rectangle;
-
- /* We redraw the whole region, but we should track the buffers and only redraw what has changed since we sent this buffer */
- rectangle.x = 0;
- rectangle.y = 0;
- rectangle.width = window->width;
- rectangle.height = window->height;
- cairo_region_union_rectangle (region, &rectangle);
-
- _gdk_window_process_updates_recurse (window, region);
-}
-
-static gint
-gdk_mir_window_impl_get_scale_factor (GdkWindow *window)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- return impl->output_scale;
-}
-
-static void
-gdk_mir_window_impl_set_opaque_region (GdkWindow *window,
- cairo_region_t *region)
-{
- /* FIXME: An optimisation to tell the compositor which regions of the window are fully transparent */
-}
-
-static void
-gdk_mir_window_impl_set_shadow_width (GdkWindow *window,
- gint left,
- gint right,
- gint top,
- gint bottom)
-{
-}
-
-static gboolean
-find_eglconfig_for_window (GdkWindow *window,
- EGLConfig *egl_config_out,
- GError **error)
-{
- GdkDisplay *display = gdk_window_get_display (window);
- EGLDisplay *egl_display = _gdk_mir_display_get_egl_display (display);
- EGLint attrs[MAX_EGL_ATTRS];
- EGLint count;
- EGLConfig *configs;
-
- int i = 0;
-
- attrs[i++] = EGL_SURFACE_TYPE;
- attrs[i++] = EGL_WINDOW_BIT;
-
- attrs[i++] = EGL_COLOR_BUFFER_TYPE;
- attrs[i++] = EGL_RGB_BUFFER;
-
- attrs[i++] = EGL_RED_SIZE;
- attrs[i++] = 1;
- attrs[i++] = EGL_GREEN_SIZE;
- attrs[i++] = 1;
- attrs[i++] = EGL_BLUE_SIZE;
- attrs[i++] = 1;
- attrs[i++] = EGL_ALPHA_SIZE;
- attrs[i++] = 1;
-
- attrs[i++] = EGL_NONE;
- g_assert (i < MAX_EGL_ATTRS);
-
- if (!eglChooseConfig (egl_display, attrs, NULL, 0, &count) || count < 1)
- {
- g_set_error_literal (error, GDK_GL_ERROR,
- GDK_GL_ERROR_UNSUPPORTED_FORMAT,
- _("No available configurations for the given pixel format"));
- return FALSE;
- }
-
- configs = g_new (EGLConfig, count);
-
- if (!eglChooseConfig (egl_display, attrs, configs, count, &count) || count < 1)
- {
- g_set_error_literal (error, GDK_GL_ERROR,
- GDK_GL_ERROR_UNSUPPORTED_FORMAT,
- _("No available configurations for the given pixel format"));
- return FALSE;
- }
-
- /* Pick first valid configuration i guess? */
-
- if (egl_config_out != NULL)
- *egl_config_out = configs[0];
-
- g_free (configs);
-
- return TRUE;
-}
-
-static GdkGLContext *
-gdk_mir_window_impl_create_gl_context (GdkWindow *window,
- gboolean attached,
- GdkGLContext *share,
- GError **error)
-{
- GdkDisplay *display = gdk_window_get_display (window);
- GdkMirGLContext *context;
- EGLConfig config;
-
- if (!_gdk_mir_display_init_egl_display (display))
- {
- g_set_error_literal (error, GDK_GL_ERROR,
- GDK_GL_ERROR_NOT_AVAILABLE,
- _("No GL implementation is available"));
- return NULL;
- }
-
- if (!_gdk_mir_display_have_egl_khr_create_context (display))
- {
- g_set_error_literal (error, GDK_GL_ERROR,
- GDK_GL_ERROR_UNSUPPORTED_PROFILE,
- _("3.2 core GL profile is not available on EGL implementation"));
- return NULL;
- }
-
- if (!find_eglconfig_for_window (window, &config, error))
- return NULL;
-
- context = g_object_new (GDK_TYPE_MIR_GL_CONTEXT,
- "window", window,
- "shared-context", share,
- NULL);
-
- context->egl_config = config;
- context->is_attached = attached;
-
- return GDK_GL_CONTEXT (context);
-}
-
-EGLSurface
-_gdk_mir_window_get_egl_surface (GdkWindow *window,
- EGLConfig config)
-{
- GdkMirWindowImpl *impl;
-
- impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- if (!impl->egl_surface)
- {
- EGLDisplay egl_display;
- EGLNativeWindowType egl_window;
-
- ensure_no_mir_window (window);
- ensure_mir_window_full (window, mir_buffer_usage_hardware);
-
- egl_display = _gdk_mir_display_get_egl_display (gdk_window_get_display (window));
- egl_window = (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window (impl->buffer_stream);
-
- impl->egl_surface =
- eglCreateWindowSurface (egl_display, config, egl_window, NULL);
- }
-
- return impl->egl_surface;
-}
-
-EGLSurface
-_gdk_mir_window_get_dummy_egl_surface (GdkWindow *window,
- EGLConfig config)
-{
- GdkMirWindowImpl *impl;
-
- impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- if (!impl->dummy_egl_surface)
- {
- GdkDisplay *display;
- EGLDisplay egl_display;
- EGLNativeWindowType egl_window;
-
- display = gdk_window_get_display (window);
- egl_display = _gdk_mir_display_get_egl_display (display);
- egl_window = (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window (impl->buffer_stream);
-
- impl->dummy_egl_surface =
- eglCreateWindowSurface (egl_display, config, egl_window, NULL);
- }
-
- return impl->dummy_egl_surface;
-}
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-MirSurface *
-gdk_mir_window_get_mir_surface (GdkWindow *window)
-{
- return _gdk_mir_window_get_mir_window (window);
-}
-
-#pragma GCC diagnostic pop
-
-MirWindow *
-_gdk_mir_window_get_mir_window (GdkWindow *window)
-{
- g_return_val_if_fail (GDK_IS_MIR_WINDOW (window), NULL);
-
- return GDK_MIR_WINDOW_IMPL (window->impl)->mir_window;
-}
-
-void
-_gdk_mir_window_set_scale (GdkWindow *window,
- gdouble scale)
-{
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- GdkRectangle area = {0, 0, window->width, window->height};
- cairo_region_t *region;
- gint new_scale = (gint) round (scale);
-
- if (impl->output_scale != new_scale)
- {
- impl->output_scale = new_scale;
-
- drop_cairo_surface (window);
-
- if (impl->buffer_stream)
- mir_buffer_stream_set_scale (impl->buffer_stream, (float) new_scale);
-
- region = cairo_region_create_rectangle (&area);
- _gdk_window_invalidate_for_expose (window, region);
- cairo_region_destroy (region);
- }
-}
-
-static void
-gdk_mir_window_impl_class_init (GdkMirWindowImplClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GdkWindowImplClass *impl_class = GDK_WINDOW_IMPL_CLASS (klass);
-
- object_class->finalize = gdk_mir_window_impl_finalize;
-
- impl_class->ref_cairo_surface = gdk_mir_window_impl_ref_cairo_surface;
- impl_class->create_similar_image_surface = gdk_mir_window_impl_create_similar_image_surface;
- impl_class->show = gdk_mir_window_impl_show;
- impl_class->hide = gdk_mir_window_impl_hide;
- impl_class->withdraw = gdk_mir_window_impl_withdraw;
- impl_class->raise = gdk_mir_window_impl_raise;
- impl_class->lower = gdk_mir_window_impl_lower;
- impl_class->restack_toplevel = gdk_mir_window_impl_restack_toplevel;
- impl_class->move_resize = gdk_mir_window_impl_move_resize;
- impl_class->move_to_rect = gdk_mir_window_impl_move_to_rect;
- impl_class->get_events = gdk_mir_window_impl_get_events;
- impl_class->set_events = gdk_mir_window_impl_set_events;
- impl_class->get_geometry = gdk_mir_window_impl_get_geometry;
- impl_class->get_root_coords = gdk_mir_window_impl_get_root_coords;
- impl_class->get_device_state = gdk_mir_window_impl_get_device_state;
- impl_class->begin_paint = gdk_mir_window_impl_begin_paint;
- impl_class->end_paint = gdk_mir_window_impl_end_paint;
- impl_class->shape_combine_region = gdk_mir_window_impl_shape_combine_region;
- impl_class->input_shape_combine_region = gdk_mir_window_impl_input_shape_combine_region;
- impl_class->destroy = gdk_mir_window_impl_destroy;
- impl_class->focus = gdk_mir_window_impl_focus;
- impl_class->set_type_hint = gdk_mir_window_impl_set_type_hint;
- impl_class->get_type_hint = gdk_mir_window_impl_get_type_hint;
- impl_class->set_modal_hint = gdk_mir_window_impl_set_modal_hint;
- impl_class->set_skip_taskbar_hint = gdk_mir_window_impl_set_skip_taskbar_hint;
- impl_class->set_skip_pager_hint = gdk_mir_window_impl_set_skip_pager_hint;
- impl_class->set_urgency_hint = gdk_mir_window_impl_set_urgency_hint;
- impl_class->set_geometry_hints = gdk_mir_window_impl_set_geometry_hints;
- impl_class->set_title = gdk_mir_window_impl_set_title;
- impl_class->set_role = gdk_mir_window_impl_set_role;
- impl_class->set_startup_id = gdk_mir_window_impl_set_startup_id;
- impl_class->set_transient_for = gdk_mir_window_impl_set_transient_for;
- impl_class->get_frame_extents = gdk_mir_window_impl_get_frame_extents;
- impl_class->set_accept_focus = gdk_mir_window_impl_set_accept_focus;
- impl_class->set_focus_on_map = gdk_mir_window_impl_set_focus_on_map;
- impl_class->set_icon_list = gdk_mir_window_impl_set_icon_list;
- impl_class->set_icon_name = gdk_mir_window_impl_set_icon_name;
- impl_class->iconify = gdk_mir_window_impl_iconify;
- impl_class->deiconify = gdk_mir_window_impl_deiconify;
- impl_class->stick = gdk_mir_window_impl_stick;
- impl_class->unstick = gdk_mir_window_impl_unstick;
- impl_class->maximize = gdk_mir_window_impl_maximize;
- impl_class->unmaximize = gdk_mir_window_impl_unmaximize;
- impl_class->fullscreen = gdk_mir_window_impl_fullscreen;
- impl_class->apply_fullscreen_mode = gdk_mir_window_impl_apply_fullscreen_mode;
- impl_class->unfullscreen = gdk_mir_window_impl_unfullscreen;
- impl_class->set_keep_above = gdk_mir_window_impl_set_keep_above;
- impl_class->set_keep_below = gdk_mir_window_impl_set_keep_below;
- impl_class->get_group = gdk_mir_window_impl_get_group;
- impl_class->set_group = gdk_mir_window_impl_set_group;
- impl_class->set_decorations = gdk_mir_window_impl_set_decorations;
- impl_class->get_decorations = gdk_mir_window_impl_get_decorations;
- impl_class->set_functions = gdk_mir_window_impl_set_functions;
- impl_class->begin_resize_drag = gdk_mir_window_impl_begin_resize_drag;
- impl_class->begin_move_drag = gdk_mir_window_impl_begin_move_drag;
- impl_class->enable_synchronized_configure = gdk_mir_window_impl_enable_synchronized_configure;
- impl_class->configure_finished = gdk_mir_window_impl_configure_finished;
- impl_class->set_opacity = gdk_mir_window_impl_set_opacity;
- impl_class->destroy_notify = gdk_mir_window_impl_destroy_notify;
- impl_class->register_dnd = gdk_mir_window_impl_register_dnd;
- impl_class->drag_begin = gdk_mir_window_impl_drag_begin;
- impl_class->process_updates_recurse = gdk_mir_window_impl_process_updates_recurse;
- impl_class->get_scale_factor = gdk_mir_window_impl_get_scale_factor;
- impl_class->set_opaque_region = gdk_mir_window_impl_set_opaque_region;
- impl_class->set_shadow_width = gdk_mir_window_impl_set_shadow_width;
- impl_class->create_gl_context = gdk_mir_window_impl_create_gl_context;
-}
+++ /dev/null
-gdk_mir_sources = files([
- 'gdkmircursor.c',
- 'gdkmirdevicemanager.c',
- 'gdkmirdisplay.c',
- 'gdkmireventsource.c',
- 'gdkmirglcontext.c',
- 'gdkmirkeyboard.c',
- 'gdkmirkeymap.c',
- 'gdkmirpointer.c',
- 'gdkmirscreen.c',
- 'gdkmirwindow.c',
- 'gdkmirwindowimpl.c',
- 'gdkmir-debug.c',
-])
-
-#gdk_mir_public_headers = []
-#install_headers(gdk_mir_public_headers, subdir: 'gtk-4.0/gdk/mir/')
-
-install_headers('gdkmir.h', subdir: 'gtk-4.0/gdk/')
-
-gdk_mir_deps = [
- mirclient_dep,
- mircookie_dep,
- libcontent_hub_glib_dep,
-]
-
-libgdk_mir = static_library('gdk-mir',
- gdk_mir_sources, gdkconfig, gdkenum_h,
- include_directories: [confinc, gdkinc],
- c_args: ['-DGDK_COMPILATION', '-DG_LOG_DOMAIN="Gdk"'],
- dependencies: [gdk_deps, gdk_mir_deps])
introspection_req = '>= 1.39.0'
wayland_proto_req = '>= 1.9'
wayland_req = '>= 1.9.91'
-mirclient_req = '>= 0.22.0'
-mircookie_req = '>= 0.17.0'
graphene_req = '>= 1.5.1'
epoxy_req = '>= 1.4'
cloudproviders_req = '>= 0.2.5'
x11_enabled = get_option('enable-x11-backend')
wayland_enabled = get_option('enable-wayland-backend')
broadway_enabled = get_option('enable-broadway-backend')
-mir_enabled = get_option('enable-mir-backend')
quartz_enabled = get_option('enable-quartz-backend')
win32_enabled = get_option('enable-win32-backend')
cloudproviders_enabled = get_option('enable-cloudproviders')
foreach backend: [ ['cairo-xlib', cairo_req, x11_enabled],
['cairo-win32', cairo_req, win32_enabled],
['cairo-quartz', cairo_req, quartz_enabled],
- ['cairo', cairo_req, broadway_enabled or wayland_enabled or mir_enabled], ]
+ ['cairo', cairo_req, broadway_enabled or wayland_enabled], ]
backend_enabled = backend.get(2)
cairo_backend_req = backend.get(1)
cairo_backend = backend.get(0)
cdata.set('HAVE_RANDR15', xrandr15_dep.found())
endif
-mir_pkgs = []
-if mir_enabled
- mirclient_dep = dependency('mirclient', version: mirclient_req)
- mircookie_dep = dependency('mircookie', version: mircookie_req)
- libcontent_hub_glib_dep = dependency('libcontenthub-glib')
-
- mir_pkgs = [
- 'mirclient', mirclient_req,
- 'mircookie', mircookie_req,
- 'libcontent-hub-glib',
- ]
-endif
-
if broadway_enabled
pc_gdk_extra_libs += ['-lz']
backend_immodules += ['broadway']
gio_pkgname = os_unix ? 'gio-unix-2.0' : 'gio-2.0'
pkgconf.set('GDK_PRIVATE_PACKAGES',
' '.join([ gio_pkgname, glib_req,
- 'epoxy', epoxy_req ] + x11_pkgs + wayland_pkgs + mir_pkgs + cairo_backends))
+ 'epoxy', epoxy_req ] + x11_pkgs + wayland_pkgs + cairo_backends))
pkgconf.set('GSK_PRIVATE_PACKAGES', '') # all already in GDK_PRIVATE_PACKAGES
pangoft2_pkgs = (wayland_enabled or x11_enabled) ? ['pangoft2'] : []
pkgconf.set('GTK_PRIVATE_PACKAGES', ' '.join(atk_pkgs + pangoft2_pkgs))
pkgs = [ 'gtk+-4.0.pc' ]
pkg_targets = ''
-foreach backend: [ 'broadway', 'mir', 'quartz', 'wayland', 'win32', 'x11', ]
+foreach backend: [ 'broadway', 'quartz', 'wayland', 'win32', 'x11', ]
if get_variable('@0@_enabled'.format(backend))
pkgs += ['gtk+-@0@-4.0.pc'.format(backend)]
pkg_targets += ' ' + backend
description : 'Enable the wayland gdk backend')
option('enable-broadway-backend', type: 'boolean', value: 'false',
description : 'Enable the broadway (HTML5) gdk backend')
-option('enable-mir-backend', type: 'boolean', value: 'false',
- description : 'Enable the Mir gdk backend (UNTESTED, NEEDS WORK)')
option('enable-win32-backend', type: 'boolean', value: 'false',
description : 'Enable the Windows gdk backend')
option('enable-quartz-backend', type: 'boolean', value: 'false',
projects / gtk4.git / commitdiff